Skip to content

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

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

import {AdminRepository} from '@app/api/admin/AdminRepository';
import {createTestAccount} from '@app/api/auth/tests/AuthTestUtils';
import {createUserID} from '@app/api/BrandedTypes';
import {getGatewayService, getSnowflakeService} from '@app/api/middleware/ServiceRegistry';
import {
	createUserCacheService,
	getAdminRepository,
	getChannelRepository,
	getGuildRepository,
	getKVAccountDeletionQueue,
	getKVBulkMessageDeletionQueue,
	getUserRepository,
} from '@app/api/middleware/ServiceSingletons';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {createTestWorkerHelpers} from '@app/api/test/SyncTaskWorkerService';
import bulkUpdateUserFlags from '@app/api/worker/tasks/admin_bulk/BulkUpdateUserFlags';
import {clearWorkerDependencies, setWorkerDependenciesForTest} from '@app/api/worker/WorkerContext';
import {UserFlags} from '@fluxer/constants/src/UserConstants';
import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, test} from 'vitest';

interface BulkJobResult {
	successful_count: number;
	failed_count: number;
	failed: Array<{
		id: string;
		error: string;
	}>;
}

const ADMIN_USER_ID = 4000000000000000000n;
const JOB_ID = 7100000000000000000n;
const MISSING_USER_ID = 4200000000000000001n;

function installWorkerDependencies(): void {
	setWorkerDependenciesForTest({
		adminRepository: getAdminRepository(),
		snowflakeService: getSnowflakeService(),
		userRepository: getUserRepository(),
		guildRepository: getGuildRepository(),
		channelRepository: getChannelRepository(),
		userCacheService: createUserCacheService(),
		deletionQueueService: getKVAccountDeletionQueue(),
		bulkMessageDeletionQueueService: getKVBulkMessageDeletionQueue(),
		gatewayService: getGatewayService(),
		stripe: null,
	});
}

describe('bulkUpdateUserFlags task', () => {
	let harness: ApiTestHarness;
	beforeAll(async () => {
		harness = await createApiTestHarness({search: 'enabled'});
	});
	afterAll(async () => {
		await harness.shutdown();
	});
	beforeEach(async () => {
		await harness.resetData();
		installWorkerDependencies();
	});
	afterEach(() => {
		clearWorkerDependencies();
	});

	test('writes a per-user audit row with the admin reason and records failed items', async () => {
		const first = await createTestAccount(harness);
		const second = await createTestAccount(harness);
		const result = (await bulkUpdateUserFlags(
			{
				user_ids: [first.userId, MISSING_USER_ID.toString(), second.userId],
				add_flags: [UserFlags.PARTNER.toString()],
				remove_flags: [UserFlags.HAS_SESSION_STARTED.toString()],
				admin_user_id: ADMIN_USER_ID.toString(),
				audit_log_reason: 'Lilith spam sweep',
			},
			createTestWorkerHelpers({jobId: JOB_ID}),
		)) as unknown as BulkJobResult;

		expect(result.successful_count).toBe(2);
		expect(result.failed_count).toBe(1);
		expect(result.failed).toEqual([{id: MISSING_USER_ID.toString(), error: 'UNKNOWN_USER'}]);

		const userRepository = getUserRepository();
		const updatedFirst = await userRepository.findUnique(createUserID(BigInt(first.userId)));
		expect(updatedFirst!.flags & UserFlags.PARTNER).toBe(UserFlags.PARTNER);
		expect(updatedFirst!.flags & UserFlags.HAS_SESSION_STARTED).toBe(0n);

		const auditLogs = await new AdminRepository().listAllAuditLogsPaginated(50);
		const perUserLogs = auditLogs.filter((log) => log.action === 'update_flags');
		expect(perUserLogs.map((log) => log.targetId).sort()).toEqual([BigInt(first.userId), BigInt(second.userId)].sort());
		for (const log of perUserLogs) {
			expect(log.targetType).toBe('user');
			expect(log.adminUserId.toString()).toBe(ADMIN_USER_ID.toString());
			expect(log.auditLogReason).toBe('Lilith spam sweep');
			expect(log.metadata.get('add_flags')).toBe(UserFlags.PARTNER.toString());
			expect(log.metadata.get('remove_flags')).toBe(UserFlags.HAS_SESSION_STARTED.toString());
			expect(log.metadata.get('new_flags')).toBe(UserFlags.PARTNER.toString());
		}
		expect(auditLogs.some((log) => log.action === 'update_flags' && log.targetId === MISSING_USER_ID)).toBe(false);
	});

	test('writes one summary row against the job id', async () => {
		const account = await createTestAccount(harness);
		await bulkUpdateUserFlags(
			{
				user_ids: [account.userId, MISSING_USER_ID.toString()],
				add_flags: [UserFlags.STAFF.toString()],
				remove_flags: [],
				admin_user_id: ADMIN_USER_ID.toString(),
				audit_log_reason: 'Staff grant',
			},
			createTestWorkerHelpers({jobId: JOB_ID}),
		);

		const auditLogs = await new AdminRepository().listAllAuditLogsPaginated(50);
		const summaryLogs = auditLogs.filter((log) => log.action === 'bulk_update_user_flags');
		expect(summaryLogs).toHaveLength(1);
		const summary = summaryLogs[0]!;
		expect(summary.targetType).toBe('bulk_job');
		expect(summary.targetId).toBe(JOB_ID);
		expect(summary.auditLogReason).toBe('Staff grant');
		expect(summary.metadata.get('user_count')).toBe('2');
		expect(summary.metadata.get('add_flags')).toBe(UserFlags.STAFF.toString());
		expect(summary.metadata.has('remove_flags')).toBe(false);
		expect(summary.metadata.get('processed')).toBe('2');
		expect(summary.metadata.get('successful')).toBe('1');
		expect(summary.metadata.get('failed')).toBe('1');
	});
});