Skip to content

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

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

import {createGuildID, createRoleID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import {AssetDeletionQueue} from '@app/api/infrastructure/AssetDeletionQueue';
import {NoopPurgeQueue} from '@app/api/infrastructure/CachePurgeQueue';
import {MockStorageService} from '@app/api/test/mocks/MockStorageService';
import {createTestWorkerHelpers} from '@app/api/test/SyncTaskWorkerService';
import {UserRepository} from '@app/api/user/repositories/UserRepository';
import processAssetDeletionQueue from '@app/api/worker/tasks/ProcessAssetDeletionQueue';
import {clearWorkerDependencies, setWorkerDependenciesForTest} from '@app/api/worker/WorkerContext';
import {MockKVProvider} from '@pkgs/kv_client/src/testing/MockKVProvider';
import {afterEach, describe, expect, it} from 'vitest';

function createHarness(storageService: MockStorageService) {
	const kvClient = new MockKVProvider();
	const assetDeletionQueue = new AssetDeletionQueue(kvClient);
	const guildRepository = new GuildRepository();
	setWorkerDependenciesForTest({
		assetDeletionQueue,
		purgeQueue: new NoopPurgeQueue(),
		storageService,
		userRepository: new UserRepository(kvClient),
		guildRepository,
	});
	return {assetDeletionQueue, guildRepository};
}

const ROLE_GUILD_ID = createGuildID(1430000000000000000n);
const ROLE_ID = createRoleID(1430000000000000001n);

async function seedRoleIcon(guildRepository: GuildRepository, iconHash: string | null): Promise<void> {
	await guildRepository.upsertRole({
		guild_id: ROLE_GUILD_ID,
		role_id: ROLE_ID,
		name: 'Artists',
		permissions: 0n,
		position: 1,
		hoist_position: null,
		color: 0,
		icon_hash: iconHash,
		unicode_emoji: null,
		hoist: false,
		mentionable: false,
		version: 1,
	});
}

function roleIconKey(hash: string): string {
	return `role-icons/${ROLE_ID}/${hash}`;
}

async function storeAndQueueRoleIcon(
	storageService: MockStorageService,
	assetDeletionQueue: AssetDeletionQueue,
	hash: string,
	withReference = true,
): Promise<void> {
	await storageService.uploadObject({bucket: Config.s3.buckets.cdn, key: roleIconKey(hash), body: new Uint8Array([1])});
	await assetDeletionQueue.queueDeletion({
		s3Key: roleIconKey(hash),
		cdnUrl: null,
		reason: 'asset_replaced',
		staleReference: withReference
			? {
					entityType: 'role',
					assetType: 'role_icon',
					entityId: ROLE_ID.toString(),
					guildId: ROLE_GUILD_ID.toString(),
					hash,
				}
			: undefined,
	});
}

async function queueAssets(assetDeletionQueue: AssetDeletionQueue, count: number): Promise<void> {
	for (let index = 0; index < count; index++) {
		await assetDeletionQueue.queueDeletion({
			s3Key: `attachments/100/200/file-${index}.png`,
			cdnUrl: null,
			reason: 'test',
		});
	}
}

describe('processAssetDeletionQueue', () => {
	afterEach(() => {
		clearWorkerDependencies();
	});

	it('attempts each queued asset once per run when storage is failing', async () => {
		const {assetDeletionQueue} = createHarness(new MockStorageService({shouldFailDelete: true}));
		await queueAssets(assetDeletionQueue, 3);

		await expect(processAssetDeletionQueue({}, createTestWorkerHelpers())).rejects.toThrow(/3 failures/);

		const remaining = await assetDeletionQueue.getBatch(10);
		expect(remaining.map((item) => item.retryCount)).toEqual([1, 1, 1]);
	});

	it('attempts each queued asset once per run across batch boundaries', async () => {
		const {assetDeletionQueue} = createHarness(new MockStorageService({shouldFailDelete: true}));
		await queueAssets(assetDeletionQueue, 60);

		await expect(processAssetDeletionQueue({}, createTestWorkerHelpers())).rejects.toThrow(/60 failures/);

		const remaining = await assetDeletionQueue.getBatch(100);
		expect(remaining).toHaveLength(60);
		expect(remaining.every((item) => item.retryCount === 1)).toBe(true);
	});

	it('drains the queue when storage succeeds', async () => {
		const {assetDeletionQueue} = createHarness(new MockStorageService());
		await queueAssets(assetDeletionQueue, 60);

		await processAssetDeletionQueue({}, createTestWorkerHelpers());

		expect(await assetDeletionQueue.getQueueSize()).toBe(0);
	});

	describe('role icons', () => {
		it('deletes a replaced role icon', async () => {
			const storageService = new MockStorageService();
			const {assetDeletionQueue, guildRepository} = createHarness(storageService);
			await seedRoleIcon(guildRepository, 'bbbbbbbb');
			await storeAndQueueRoleIcon(storageService, assetDeletionQueue, 'aaaaaaaa');

			await processAssetDeletionQueue({}, createTestWorkerHelpers());

			expect(storageService.hasObject(Config.s3.buckets.cdn, roleIconKey('aaaaaaaa'))).toBe(false);
		});

		it('keeps the current role icon', async () => {
			const storageService = new MockStorageService();
			const {assetDeletionQueue, guildRepository} = createHarness(storageService);
			await seedRoleIcon(guildRepository, 'aaaaaaaa');
			await storeAndQueueRoleIcon(storageService, assetDeletionQueue, 'aaaaaaaa');

			await processAssetDeletionQueue({}, createTestWorkerHelpers());

			expect(storageService.hasObject(Config.s3.buckets.cdn, roleIconKey('aaaaaaaa'))).toBe(true);
		});

		it('keeps a role icon queued without a stale reference', async () => {
			const storageService = new MockStorageService();
			const {assetDeletionQueue, guildRepository} = createHarness(storageService);
			await seedRoleIcon(guildRepository, null);
			await storeAndQueueRoleIcon(storageService, assetDeletionQueue, 'aaaaaaaa', false);

			await processAssetDeletionQueue({}, createTestWorkerHelpers());

			expect(storageService.hasObject(Config.s3.buckets.cdn, roleIconKey('aaaaaaaa'))).toBe(true);
			expect(await assetDeletionQueue.getQueueSize()).toBe(0);
		});
	});
});