Skip to content

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

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

import {authorizeBot, createTestBotAccount} from '@app/api/bot/tests/BotTestUtils';
import {createChannel, createRole, setupTestGuildWithMembers, updateRole} from '@app/api/guild/tests/GuildTestUtils';
import {deleteMessage, sendMessage} from '@app/api/message/tests/MessageTestUtils';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';
import {createWebhook} from '@app/api/webhook/tests/WebhookTestUtils';
import {AuditLogActionType} from '@fluxer/constants/src/AuditLogActionType';
import {Permissions} from '@fluxer/constants/src/ChannelConstants';
import {afterEach, beforeEach, describe, expect, test} from 'vitest';

interface AuditLogChange {
	key: string;
	old_value?: unknown;
	new_value?: unknown;
}

interface AuditLogOptions {
	channel_id?: string;
	max_age?: number;
	max_uses?: number;
	temporary?: boolean;
}

interface AuditLogEntry {
	id: string;
	action_type: number;
	user_id: string | null;
	target_id: string | null;
	reason?: string;
	options?: AuditLogOptions;
	changes?: Array<AuditLogChange>;
}

interface AuditLogWebhook {
	id: string;
	type: number;
	guild_id: string | null;
	channel_id: string | null;
	name: string;
	avatar_hash: string | null;
}

interface AuditLogResponse {
	audit_log_entries: Array<AuditLogEntry>;
	users: Array<{
		id: string;
	}>;
	webhooks: Array<AuditLogWebhook>;
}

describe('Guild audit log endpoint', () => {
	let harness: ApiTestHarness;
	beforeEach(async () => {
		harness = await createApiTestHarness();
	});
	afterEach(async () => {
		await harness?.shutdown();
	});
	test('rejects unauthenticated requests', async () => {
		const {guild} = await setupTestGuildWithMembers(harness, 1);
		await createBuilderWithoutAuth(harness)
			.get(`/guilds/${guild.id}/audit-logs`)
			.expect(HTTP_STATUS.UNAUTHORIZED)
			.execute();
	});
	test('requires view audit log permission', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		await updateRole(harness, owner.token, guild.id, guild.id, {
			permissions: Permissions.VIEW_CHANNEL.toString(),
		});
		await createBuilder(harness, member.token)
			.get(`/guilds/${guild.id}/audit-logs`)
			.expect(HTTP_STATUS.FORBIDDEN)
			.execute();
	});
	test('allows bot tokens with view audit log permission', async () => {
		const {owner, guild} = await setupTestGuildWithMembers(harness, 0);
		const botAccount = await createTestBotAccount(harness);
		await authorizeBot(
			harness,
			owner.token,
			botAccount.appId,
			['bot'],
			guild.id,
			Permissions.VIEW_AUDIT_LOG.toString(),
		);
		await createRole(harness, owner.token, guild.id, {
			name: 'Bot audit role',
			permissions: Permissions.VIEW_CHANNEL.toString(),
		});
		const response = await createBuilder<AuditLogResponse>(harness, `Bot ${botAccount.botToken}`)
			.get(`/guilds/${guild.id}/audit-logs?action_type=${AuditLogActionType.ROLE_CREATE}`)
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(response.audit_log_entries.length).toBeGreaterThan(0);
	});
	test('returns webhook references for webhook audit log entries', async () => {
		const {owner, guild} = await setupTestGuildWithMembers(harness, 1);
		const channel = await createChannel(harness, owner.token, guild.id, 'hooks');
		const webhook = await createWebhook(harness, channel.id, owner.token, 'Audit Webhook');
		const response = await createBuilder<AuditLogResponse>(harness, owner.token)
			.get(`/guilds/${guild.id}/audit-logs?action_type=${AuditLogActionType.WEBHOOK_CREATE}`)
			.execute();
		const entry = response.audit_log_entries.find((log) => log.target_id === webhook.id);
		expect(entry).toBeDefined();
		expect(entry?.options?.channel_id).toBe(channel.id);
		const webhookEntry = response.webhooks.find((record) => record.id === webhook.id);
		expect(webhookEntry).toBeDefined();
		expect(webhookEntry?.channel_id).toBe(channel.id);
		expect(webhookEntry?.guild_id).toBe(guild.id);
	});
	test('filters audit logs by user and action type', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		await createRole(harness, owner.token, guild.id, {
			name: 'Owner Role',
			permissions: Permissions.VIEW_CHANNEL.toString(),
		});
		await createBuilder(harness, member.token)
			.patch(`/guilds/${guild.id}/members/@me`)
			.body({nick: 'Audit Nick'})
			.expect(HTTP_STATUS.OK)
			.execute();
		const responseByUser = await createBuilder<AuditLogResponse>(harness, owner.token)
			.get(`/guilds/${guild.id}/audit-logs?user_id=${member.userId}`)
			.execute();
		expect(responseByUser.audit_log_entries.length).toBeGreaterThan(0);
		for (const entry of responseByUser.audit_log_entries) {
			expect(entry.user_id).toBe(member.userId);
		}
		const responseByAction = await createBuilder<AuditLogResponse>(harness, owner.token)
			.get(`/guilds/${guild.id}/audit-logs?action_type=${AuditLogActionType.ROLE_CREATE}`)
			.execute();
		expect(responseByAction.audit_log_entries.length).toBeGreaterThan(0);
		for (const entry of responseByAction.audit_log_entries) {
			expect(entry.action_type).toBe(AuditLogActionType.ROLE_CREATE);
		}
	});
	test('serves a created entry through every audit log index', async () => {
		const {owner, guild} = await setupTestGuildWithMembers(harness, 1);
		const role = await createRole(harness, owner.token, guild.id, {
			name: 'Index Role',
			permissions: Permissions.VIEW_CHANNEL.toString(),
		});
		const queries = [
			'',
			`?user_id=${owner.userId}`,
			`?action_type=${AuditLogActionType.ROLE_CREATE}`,
			`?user_id=${owner.userId}&action_type=${AuditLogActionType.ROLE_CREATE}`,
		];
		for (const query of queries) {
			const response = await createBuilder<AuditLogResponse>(harness, owner.token)
				.get(`/guilds/${guild.id}/audit-logs${query}`)
				.execute();
			const entry = response.audit_log_entries.find((log) => log.target_id === role.id);
			expect(entry, `missing entry for query "${query}"`).toBeDefined();
			expect(entry?.action_type).toBe(AuditLogActionType.ROLE_CREATE);
			expect(entry?.user_id).toBe(owner.userId);
			const nameChange = entry?.changes?.find((change) => change.key === 'name');
			expect(nameChange?.new_value).toBe('Index Role');
		}
	});
	test('includes target users for user-target audit log entries', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const banReason = 'Audit log user list check';
		await createBuilder(harness, owner.token)
			.put(`/guilds/${guild.id}/bans/${member.userId}`)
			.body({reason: banReason})
			.expect(HTTP_STATUS.NO_CONTENT)
			.execute();
		const response = await createBuilder<AuditLogResponse>(harness, owner.token)
			.get(`/guilds/${guild.id}/audit-logs?action_type=${AuditLogActionType.MEMBER_BAN_ADD}`)
			.execute();
		const userIds = response.users.map((user) => user.id);
		expect(userIds).toContain(owner.userId);
		expect(userIds).toContain(member.userId);
		const entry = response.audit_log_entries.find((log) => log.target_id === member.userId);
		expect(entry?.reason).toBe(banReason);
	});
	test('fills a page from behind a long run of batched message deletes', async () => {
		const {owner, guild, channels} = await setupTestGuildWithMembers(harness, 0);
		const channel = channels[0];
		await createRole(harness, owner.token, guild.id, {
			name: 'Older Role',
			permissions: Permissions.VIEW_CHANNEL.toString(),
		});
		for (let index = 0; index < 60; index++) {
			const message = await sendMessage(harness, owner.token, channel.id, `delete me ${index}`);
			await deleteMessage(harness, owner.token, channel.id, message.id);
		}
		const response = await createBuilder<AuditLogResponse>(harness, owner.token)
			.get(`/guilds/${guild.id}/audit-logs?limit=6`)
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(response.audit_log_entries).toHaveLength(6);
		expect(response.audit_log_entries.slice(0, 5).map((entry) => entry.action_type)).toEqual(
			Array.from({length: 5}, () => AuditLogActionType.MESSAGE_BULK_DELETE),
		);
		expect(response.audit_log_entries[5]?.action_type).toBe(AuditLogActionType.ROLE_CREATE);
	});
});