Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
4.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {createTestAccount} from '@app/api/auth/tests/AuthTestUtils';
import {createApplicationID, createUserID} from '@app/api/BrandedTypes';
import {getGatewayService} from '@app/api/middleware/ServiceRegistry';
import {
	createUserCacheService,
	getApplicationRepository,
	getGuildRepository,
	getUserRepository,
} from '@app/api/middleware/ServiceSingletons';
import {createOAuth2Application, createUniqueApplicationName} from '@app/api/oauth/tests/OAuth2TestUtils';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {createTestWorkerHelpers} from '@app/api/test/SyncTaskWorkerService';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';
import applicationProcessDeletion from '@app/api/worker/tasks/ApplicationProcessDeletion';
import {clearWorkerDependencies, setWorkerDependenciesForTest} from '@app/api/worker/WorkerContext';
import {UserFlags} from '@fluxer/constants/src/UserConstants';
import type {MessageResponse} from '@fluxer/schema/src/domains/message/MessageResponseSchemas';
import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, test} from 'vitest';

describe('applicationProcessDeletion task', () => {
	let harness: ApiTestHarness;
	beforeAll(async () => {
		harness = await createApiTestHarness();
	});
	afterAll(async () => {
		await harness.shutdown();
	});
	beforeEach(async () => {
		await harness.resetData();
		setWorkerDependenciesForTest({
			userRepository: getUserRepository(),
			guildRepository: getGuildRepository(),
			applicationRepository: getApplicationRepository(),
			userCacheService: createUserCacheService(),
			gatewayService: getGatewayService(),
		});
	});
	afterEach(() => {
		clearWorkerDependencies();
	});

	test('keeps the bot as author of its messages and clears its profile', async () => {
		const account = await createTestAccount(harness);
		const createResult = await createOAuth2Application(harness, account.token, {
			name: createUniqueApplicationName(),
		});
		const botUserId = createUserID(BigInt(createResult.botUserId));
		const userRepository = getUserRepository();
		const botUser = await userRepository.findUniqueAssert(botUserId);
		await userRepository.patchUpsert(
			botUserId,
			{
				avatar_hash: 'a'.repeat(32),
				banner_hash: 'b'.repeat(32),
				bio: 'bot bio',
				pronouns: 'it/its',
				accent_color: 0x4641d9,
			},
			botUser.toRow(),
		);
		const guild = await createBuilder<{
			id: string;
			system_channel_id?: string;
		}>(harness, account.token)
			.post('/guilds')
			.body({name: `Bot Message Retention ${Date.now()}`})
			.expect(HTTP_STATUS.OK)
			.execute();
		const channelId = guild.system_channel_id;
		if (!channelId) {
			throw new Error('Guild response missing system channel');
		}
		const seeded = await createBuilder<{
			messages: Array<{
				message_id: string;
			}>;
		}>(harness, '')
			.post('/test/messages/seed')
			.body({
				channel_id: channelId,
				author_id: createResult.botUserId,
				clear_existing: true,
				messages: [{content: 'bot message before deletion'}],
			})
			.expect(HTTP_STATUS.OK)
			.execute();
		const botMessageId = seeded.messages[0]?.message_id;
		if (!botMessageId) {
			throw new Error('Seeded message response missing message id');
		}

		await applicationProcessDeletion(
			{applicationId: createResult.application.id},
			createTestWorkerHelpers({jobId: 7200000000000000000n}),
		);

		expect(
			await getApplicationRepository().getApplication(createApplicationID(BigInt(createResult.application.id))),
		).toBeNull();
		const deletedBot = await userRepository.findUniqueAssert(botUserId);
		expect(deletedBot.isBot).toBe(true);
		expect(deletedBot.flags & UserFlags.DELETED).toBe(UserFlags.DELETED);
		expect(deletedBot.username).toBe('DeletedUser');
		expect(deletedBot.avatarHash).toBeNull();
		expect(deletedBot.bannerHash).toBeNull();
		expect(deletedBot.bio).toBeNull();
		expect(deletedBot.pronouns).toBeNull();
		expect(deletedBot.accentColor).toBeNull();
		const messages = await createBuilder<Array<MessageResponse>>(harness, account.token)
			.get(`/channels/${channelId}/messages`)
			.expect(HTTP_STATUS.OK)
			.execute();
		const foundMessage = messages.find((message) => message.id === botMessageId);
		expect(foundMessage?.author.id).toBe(createResult.botUserId);
		expect(foundMessage?.author.bot).toBe(true);
		expect(foundMessage?.author.username).toBe('DeletedUser');
		expect(foundMessage?.author.discriminator).toBe('0000');
		expect(foundMessage?.author.avatar).toBeNull();
		const authorCount = await createBuilderWithoutAuth<{
			count: number;
		}>(harness)
			.get(`/test/users/${createResult.botUserId}/messages/count`)
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(authorCount.count).toBe(1);
	});
});