Skip to content

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

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

import type {AdminAuditCoverageCase} from '@app/api/admin/tests/audit_coverage/AdminAuditCoverage';
import {createTestAccount} from '@app/api/auth/tests/AuthTestUtils';
import {
	createDmChannel,
	createFriendship,
	createGroupDmChannel,
	createGuild,
} from '@app/api/channel/tests/ChannelTestUtils';
import {getUserActivityBuffer} from '@app/api/middleware/ServiceSingletons';
import {HTTP_STATUS, TEST_CREDENTIALS} from '@app/api/test/TestConstants';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {AdminACLs} from '@fluxer/constants/src/AdminACLs';

const MISSING_USER_ID = '999999999999999999';
const LAST_ACTIVE_IP = '198.51.100.91';

export const UserAdminAuditCases: ReadonlyArray<AdminAuditCoverageCase> = [
	{
		method: 'GET',
		route: '/admin/acls',
		async prepare() {
			return {
				request: {path: '/admin/acls'},
				expected: {
					action: 'list_admin_acls',
					targetType: 'admin_acl',
					targetId: '0',
					metadata: {acl_count: String(Object.values(AdminACLs).length)},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/@me',
		exempt: true,
		async prepare() {
			return {request: {path: '/admin/users/@me'}};
		},
	},
	{
		method: 'GET',
		route: '/admin/users',
		name: 'user_id',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			return {
				request: {path: `/admin/users?user_id=${target.userId}`},
				expected: {
					action: 'search_users',
					targetType: 'user',
					targetId: '0',
					metadata: {
						selector: 'user_id',
						user_id: target.userId,
						user_id_count: '1',
						result_count: '1',
						total: '1',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users',
		name: 'several user_id',
		async prepare({harness}) {
			const first = await createTestAccount(harness);
			const second = await createTestAccount(harness);
			return {
				request: {path: `/admin/users?user_id=${first.userId}&user_id=${second.userId}&user_id=${MISSING_USER_ID}`},
				expected: {
					action: 'search_users',
					targetType: 'user',
					targetId: '0',
					metadata: {
						selector: 'user_id',
						user_id_count: '3',
						result_count: '2',
						total: '2',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users',
		name: 'resolve',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			return {
				request: {path: `/admin/users?resolve=${encodeURIComponent(target.email)}`},
				expected: {
					action: 'search_users',
					targetType: 'user',
					targetId: '0',
					metadata: {
						selector: 'resolve',
						result_count: '1',
						total: '1',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users',
		name: 'email',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			return {
				request: {path: `/admin/users?email=${encodeURIComponent(target.email)}&limit=10`},
				expected: {
					action: 'search_users',
					targetType: 'user',
					targetId: '0',
					metadata: {
						selector: 'email',
						result_count: '1',
						total: '1',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users',
		name: 'last_active_ip',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			await createBuilder(harness, target.token)
				.get('/users/@me')
				.header('x-forwarded-for', LAST_ACTIVE_IP)
				.expect(HTTP_STATUS.OK)
				.execute();
			await getUserActivityBuffer().drainAndFlush();
			return {
				request: {path: `/admin/users?last_active_ip=${encodeURIComponent(LAST_ACTIVE_IP)}&limit=10&offset=0`},
				expected: {
					action: 'search_users',
					targetType: 'user',
					targetId: '0',
					metadata: {
						selector: 'last_active_ip',
						limit: '10',
						offset: '0',
						result_count: '1',
						total: '1',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users',
		name: 'acl',
		async prepare() {
			return {
				request: {path: `/admin/users?acl=${encodeURIComponent(AdminACLs.WILDCARD)}&limit=10&offset=0`},
				expected: {
					action: 'search_users',
					targetType: 'user',
					targetId: '0',
					metadata: {
						selector: 'acl',
						acl: AdminACLs.WILDCARD,
						limit: '10',
						offset: '0',
						result_count: '1',
						total: '1',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users',
		name: 'search',
		search: 'enabled',
		async prepare() {
			return {
				request: {path: '/admin/users?q=nobody-matches-this-query&limit=25'},
				expected: {
					action: 'search_users',
					targetType: 'user',
					targetId: '0',
					metadata: {
						selector: 'search',
						has_query: 'true',
						limit: '25',
						offset: '0',
						result_count: '0',
						total: '0',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id',
		name: 'found',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			return {
				request: {path: `/admin/users/${target.userId}`},
				expected: {
					action: 'get_user',
					targetType: 'user',
					targetId: target.userId,
					metadata: {found: 'true'},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id',
		name: 'missing',
		async prepare() {
			return {
				request: {path: `/admin/users/${MISSING_USER_ID}`},
				expected: {
					action: 'get_user',
					targetType: 'user',
					targetId: MISSING_USER_ID,
					metadata: {found: 'false'},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id/guilds',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			await createGuild(harness, target.token, 'Audit Guild One');
			const second = await createGuild(harness, target.token, 'Audit Guild Two');
			return {
				request: {path: `/admin/users/${target.userId}/guilds?before=${second.id}&limit=50`},
				expected: {
					action: 'list_user_guilds',
					targetType: 'user',
					targetId: target.userId,
					metadata: {
						before_guild_id: second.id,
						limit: '50',
						with_counts: 'false',
						guild_count: '1',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id/dm-channels',
		name: 'dm',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			const first = await createTestAccount(harness);
			const second = await createTestAccount(harness);
			await createFriendship(harness, target, first);
			await createFriendship(harness, target, second);
			const firstDm = await createDmChannel(harness, target.token, first.userId);
			await createDmChannel(harness, target.token, second.userId);
			return {
				request: {path: `/admin/users/${target.userId}/dm-channels?after=${firstDm.id}&limit=10`},
				expected: {
					action: 'list_user_dm_channels',
					targetType: 'user',
					targetId: target.userId,
					metadata: {
						type: 'dm',
						after_channel_id: firstDm.id,
						limit: '10',
						channel_count: '1',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id/dm-channels',
		name: 'group_dm',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			const first = await createTestAccount(harness);
			const second = await createTestAccount(harness);
			await createFriendship(harness, target, first);
			await createFriendship(harness, target, second);
			await createGroupDmChannel(harness, target.token, [first.userId, second.userId]);
			return {
				request: {path: `/admin/users/${target.userId}/dm-channels?type=group_dm`},
				expected: {
					action: 'list_user_dm_channels',
					targetType: 'user',
					targetId: target.userId,
					metadata: {type: 'group_dm', channel_count: '1'},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id/change-log',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			for (const username of ['auditfirstname', 'auditsecondname']) {
				await createBuilder(harness, target.token)
					.patch('/users/@me')
					.body({username, password: TEST_CREDENTIALS.STRONG_PASSWORD})
					.expect(HTTP_STATUS.OK)
					.execute();
			}
			return {
				request: {path: `/admin/users/${target.userId}/change-log?limit=50`},
				expected: {
					action: 'list_user_change_log',
					targetType: 'user',
					targetId: target.userId,
					metadata: {
						limit: '50',
						entry_count: '2',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id/relationships',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			const friend = await createTestAccount(harness);
			const requested = await createTestAccount(harness);
			await createFriendship(harness, target, friend);
			await createBuilder(harness, target.token)
				.post(`/users/@me/relationships/${requested.userId}`)
				.body({})
				.execute();
			return {
				request: {path: `/admin/users/${target.userId}/relationships`},
				expected: {
					action: 'list_user_relationships',
					targetType: 'user',
					targetId: target.userId,
					metadata: {
						friend_count: '1',
						incoming_request_count: '0',
						outgoing_request_count: '1',
						blocked_count: '0',
					},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id/sessions',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			return {
				request: {path: `/admin/users/${target.userId}/sessions`},
				expected: {
					action: 'list_user_sessions',
					targetType: 'user',
					targetId: target.userId,
					metadata: {session_count: '1'},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/app-sessions',
		async prepare() {
			return {
				request: {path: '/admin/app-sessions?platform=ios&release_channel=beta'},
				expected: {
					action: 'list_app_sessions',
					targetType: 'user',
					targetId: '0',
					metadata: {platform: 'ios', release_channel: 'beta', has_cursor: 'false', result_count: '0'},
				},
			};
		},
	},
	{
		method: 'GET',
		route: '/admin/users/:user_id/webauthn-credentials',
		async prepare({harness}) {
			const target = await createTestAccount(harness);
			return {
				request: {path: `/admin/users/${target.userId}/webauthn-credentials`},
				expected: {
					action: 'list_webauthn_credentials',
					targetType: 'user',
					targetId: target.userId,
					metadata: {credential_count: '0'},
				},
			};
		},
	},
];