Skip to content

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

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

import {createTestAccount} from '@app/api/auth/tests/AuthTestUtils';
import {getPngDataUrl} from '@app/api/emoji/tests/EmojiTestUtils';
import {
	addMemberRole,
	createRole,
	getMember,
	setupTestGuildWithMembers,
	updateMember,
	updateRolePositions,
} from '@app/api/guild/tests/GuildTestUtils';
import {ensureSessionStarted} from '@app/api/message/tests/MessageTestUtils';
import {profileSubstringBlocklistCache} from '@app/api/middleware/ProfileSubstringBlocklistCache';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {grantPremium} from '@app/api/user/tests/UserTestUtils';
import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';
import {Permissions} from '@fluxer/constants/src/ChannelConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import type {GuildBanResponse, GuildMemberResponse} from '@fluxer/schema/src/domains/guild/GuildMemberSchemas';
import {afterEach, beforeEach, describe, expect, test} from 'vitest';

describe('Guild Member Management', () => {
	let harness: ApiTestHarness;
	beforeEach(async () => {
		harness = await createApiTestHarness();
	});
	afterEach(async () => {
		for (const scope of ['nickname', 'bio', 'pronouns'] as const) {
			profileSubstringBlocklistCache.remove(scope, 'blockedslug');
		}
		await harness?.shutdown();
	});
	test('should reject assigning @everyone via member update', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		type InvalidFormResponse = {
			errors: Array<{
				path: string;
			}>;
			code: string;
		};
		const {json} = await createBuilder<InvalidFormResponse>(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({roles: [guild.id]})
			.expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.INVALID_FORM_BODY)
			.executeWithResponse();
		expect(json.errors?.some((error) => error.path === 'roles')).toBe(true);
	});
	test('should reject adding @everyone role explicitly', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		type InvalidFormResponse = {
			errors: Array<{
				path: string;
			}>;
			code: string;
		};
		const {json} = await createBuilder<InvalidFormResponse>(harness, owner.token)
			.put(`/guilds/${guild.id}/members/${member.userId}/roles/${guild.id}`)
			.expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.INVALID_FORM_BODY)
			.executeWithResponse();
		expect(json.errors?.some((error) => error.path === 'role_id')).toBe(true);
	});
	test('should block banned profile substrings in member nickname', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		profileSubstringBlocklistCache.add('nickname', 'blockedslug');
		await createBuilder(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({nick: 'BlockedSlug Nick'})
			.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.CONTENT_BLOCKED)
			.execute();
	});
	test('should require MANAGE_NICKNAMES to change others nickname', async () => {
		const {members, guild} = await setupTestGuildWithMembers(harness, 2);
		const [member1, member2] = members;
		await createBuilder(harness, member1.token)
			.patch(`/guilds/${guild.id}/members/${member2.userId}`)
			.body({nick: 'New Nick'})
			.expect(HTTP_STATUS.FORBIDDEN)
			.execute();
	});
	test('should require MANAGE_ROLES to add roles', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 2);
		const [member1, member2] = members;
		const role = await createRole(harness, owner.token, guild.id, {
			name: 'Test Role',
		});
		await createBuilder(harness, member1.token)
			.put(`/guilds/${guild.id}/members/${member2.userId}/roles/${role.id}`)
			.expect(HTTP_STATUS.FORBIDDEN)
			.execute();
	});
	test('should require KICK_MEMBERS to kick members', async () => {
		const {members, guild} = await setupTestGuildWithMembers(harness, 2);
		const [member1, member2] = members;
		await createBuilder(harness, member1.token)
			.delete(`/guilds/${guild.id}/members/${member2.userId}`)
			.expect(HTTP_STATUS.FORBIDDEN)
			.execute();
	});
	test('should not allow kicking the owner', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const modRole = await createRole(harness, owner.token, guild.id, {
			name: 'Moderator',
			permissions: Permissions.KICK_MEMBERS.toString(),
		});
		await addMemberRole(harness, owner.token, guild.id, member.userId, modRole.id);
		await createBuilder(harness, member.token)
			.delete(`/guilds/${guild.id}/members/${owner.userId}`)
			.expect(HTTP_STATUS.NOT_FOUND)
			.execute();
	});
	test('should reject a ban body that is not valid JSON', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const {json} = await createBuilder<{
			code: string;
			errors: Array<{
				path: string;
				code: string;
			}>;
		}>(harness, owner.token)
			.put(`/guilds/${guild.id}/bans/${member.userId}`)
			.body('{not json')
			.expect(HTTP_STATUS.BAD_REQUEST)
			.executeWithResponse();
		expect(json.code).toBe(APIErrorCodes.INVALID_FORM_BODY);
		const bodyError = json.errors.find((entry) => entry.path === 'body');
		expect(bodyError).toBeDefined();
		expect(bodyError?.code).toBe(ValidationErrorCodes.INVALID_FORMAT);
		const bans = await createBuilder<Array<GuildBanResponse>>(harness, owner.token)
			.get(`/guilds/${guild.id}/bans`)
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(bans.find((entry) => entry.user.id === member.userId)).toBeUndefined();
	});
	test('should disallow banning nonexistent user from guild', async () => {
		const {owner, guild} = await setupTestGuildWithMembers(harness, 1);
		const nonExistentId = '1234567890123456789';
		await createBuilder(harness, owner.token)
			.put(`/guilds/${guild.id}/bans/${nonExistentId}`)
			.body({})
			.expect(HTTP_STATUS.NOT_FOUND)
			.execute();
	});
	test('should fall back to audit log reason header when ban reason is omitted', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const auditLogReason = 'Header fallback guild ban reason';
		await createBuilder(harness, owner.token)
			.put(`/guilds/${guild.id}/bans/${member.userId}`)
			.header('X-Audit-Log-Reason', auditLogReason)
			.body({})
			.expect(HTTP_STATUS.NO_CONTENT)
			.execute();
		const bans = await createBuilder<Array<GuildBanResponse>>(harness, owner.token)
			.get(`/guilds/${guild.id}/bans`)
			.expect(HTTP_STATUS.OK)
			.execute();
		const ban = bans.find((entry) => entry.user.id === member.userId);
		expect(ban).toBeDefined();
		expect(ban?.reason).toBe(auditLogReason);
	});
	test('should require BAN_MEMBERS to ban members', async () => {
		const {members, guild} = await setupTestGuildWithMembers(harness, 2);
		const [member1, member2] = members;
		await createBuilder(harness, member1.token)
			.put(`/guilds/${guild.id}/bans/${member2.userId}`)
			.body({})
			.expect(HTTP_STATUS.FORBIDDEN)
			.execute();
	});
	test('should not allow member to ban themselves', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const modRole = await createRole(harness, owner.token, guild.id, {
			name: 'Moderator',
			permissions: Permissions.BAN_MEMBERS.toString(),
		});
		await addMemberRole(harness, owner.token, guild.id, member.userId, modRole.id);
		await createBuilder(harness, member.token)
			.put(`/guilds/${guild.id}/bans/${member.userId}`)
			.body({})
			.expect(HTTP_STATUS.NOT_FOUND)
			.execute();
	});
	test('should prevent a timed-out member from changing their own nickname', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const [member] = members;
		const timeoutUntil = new Date(Date.now() + 5 * 60 * 1000).toISOString();
		await createBuilder(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({communication_disabled_until: timeoutUntil})
			.expect(HTTP_STATUS.OK)
			.execute();
		await createBuilder(harness, member.token)
			.patch(`/guilds/${guild.id}/members/@me`)
			.body({nick: 'While Timed Out'})
			.expect(HTTP_STATUS.FORBIDDEN)
			.execute();
		const fetched = await getMember(harness, owner.token, guild.id, member.userId);
		expect(fetched.nick).toBeNull();
	});
	test('should still allow a moderator to change a timed-out member nickname', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const [member] = members;
		const timeoutUntil = new Date(Date.now() + 5 * 60 * 1000).toISOString();
		await createBuilder(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({communication_disabled_until: timeoutUntil})
			.expect(HTTP_STATUS.OK)
			.execute();
		const updated = await createBuilder<GuildMemberResponse>(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({nick: 'Moderator Set'})
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(updated.nick).toBe('Moderator Set');
	});
	test('should clear a timeout when communication_disabled_until is an empty string', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const timeoutUntil = new Date(Date.now() + 5 * 60 * 1000).toISOString();
		const timedOutMember = await createBuilder<GuildMemberResponse>(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({
				communication_disabled_until: timeoutUntil,
				timeout_reason: 'Compatibility test timeout',
			})
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(timedOutMember.communication_disabled_until).toBe(timeoutUntil);
		const clearedMember = await createBuilder<GuildMemberResponse>(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({
				communication_disabled_until: '',
			})
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(clearedMember.communication_disabled_until).toBeNull();
	});
	test('should ignore invalid role IDs when updating a member', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const validRole = await createRole(harness, owner.token, guild.id, {
			name: 'Valid Role',
		});
		const invalidRoleId = '999999999999999998';
		const updatedMember = await createBuilder<GuildMemberResponse>(harness, owner.token)
			.patch(`/guilds/${guild.id}/members/${member.userId}`)
			.body({roles: [validRole.id, invalidRoleId]})
			.expect(HTTP_STATUS.OK)
			.execute();
		expect(updatedMember.roles).toContain(validRole.id);
		expect(updatedMember.roles).not.toContain(invalidRoleId);
	});
	describe('List Members Permission Checks', () => {
		test('should reject non-member from listing guild members', async () => {
			const {guild} = await setupTestGuildWithMembers(harness, 1);
			const nonMember = await createTestAccount(harness);
			await createBuilder(harness, nonMember.token)
				.get(`/guilds/${guild.id}/members`)
				.expect(HTTP_STATUS.NOT_FOUND)
				.execute();
		});
		test('should support limit parameter for listing members', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 3);
			const firstPage = await createBuilder<Array<GuildMemberResponse>>(harness, owner.token)
				.get(`/guilds/${guild.id}/members?limit=2`)
				.expect(HTTP_STATUS.OK)
				.execute();
			expect(firstPage.map((entry) => entry.user.id)).toEqual([owner.userId, members[0].userId]);
			const secondPage = await createBuilder<Array<GuildMemberResponse>>(harness, owner.token)
				.get(`/guilds/${guild.id}/members?limit=2&after=${members[0].userId}`)
				.expect(HTTP_STATUS.OK)
				.execute();
			expect(secondPage.map((entry) => entry.user.id)).toEqual([members[1].userId, members[2].userId]);
		});
	});
	describe('Get Member Permission Checks', () => {
		test('should reject non-member from getting member info', async () => {
			const {members, guild} = await setupTestGuildWithMembers(harness, 1);
			const nonMember = await createTestAccount(harness);
			await createBuilder(harness, nonMember.token)
				.get(`/guilds/${guild.id}/members/${members[0].userId}`)
				.expect(HTTP_STATUS.NOT_FOUND)
				.execute();
		});
	});
	describe('Update Member Nick Permission Checks', () => {
		test('should block banned profile substrings in community profile bio and pronouns', async () => {
			const {members, guild} = await setupTestGuildWithMembers(harness, 1);
			const member = members[0];
			await ensureSessionStarted(harness, member.token);
			await grantPremium(harness, member.userId, 2);
			profileSubstringBlocklistCache.add('bio', 'blockedslug');
			profileSubstringBlocklistCache.add('pronouns', 'blockedslug');
			await createBuilder(harness, member.token)
				.patch(`/guilds/${guild.id}/members/@me`)
				.body({bio: 'community bio with blockedslug'})
				.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.CONTENT_BLOCKED)
				.execute();
			await createBuilder(harness, member.token)
				.patch(`/guilds/${guild.id}/members/@me`)
				.body({pronouns: 'blockedslug'})
				.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.CONTENT_BLOCKED)
				.execute();
		});
		test('should ignore a disallowed self nickname change while still updating other profile fields', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
			const member = members[0];
			await ensureSessionStarted(harness, member.token);
			await grantPremium(harness, member.userId, 2);
			await createBuilder(harness, owner.token)
				.patch(`/guilds/${guild.id}/roles/${guild.id}`)
				.body({
					permissions: (Permissions.VIEW_CHANNEL | Permissions.SEND_MESSAGES).toString(),
				})
				.execute();
			const updatedMember = await createBuilder<GuildMemberResponse>(harness, member.token)
				.patch(`/guilds/${guild.id}/members/@me`)
				.body({nick: 'Ignored Nick', avatar: getPngDataUrl()})
				.expect(HTTP_STATUS.OK)
				.execute();
			expect(updatedMember.nick ?? null).toBeNull();
			expect(updatedMember.avatar).toBeTruthy();
		});
	});
	describe('Kick Member Permission Checks', () => {
		test('should not allow member to kick someone with higher role', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 2);
			const [moderator, target] = members;
			const modRole = await createRole(harness, owner.token, guild.id, {
				name: 'Moderator',
				permissions: Permissions.KICK_MEMBERS.toString(),
			});
			const targetRole = await createRole(harness, owner.token, guild.id, {
				name: 'Target Role',
			});
			await updateRolePositions(harness, owner.token, guild.id, [
				{id: targetRole.id, position: 3},
				{id: modRole.id, position: 2},
			]);
			await addMemberRole(harness, owner.token, guild.id, moderator.userId, modRole.id);
			await addMemberRole(harness, owner.token, guild.id, target.userId, targetRole.id);
			await createBuilder(harness, moderator.token)
				.delete(`/guilds/${guild.id}/members/${target.userId}`)
				.expect(HTTP_STATUS.FORBIDDEN)
				.execute();
		});
		test('should not allow member to kick themselves', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
			const member = members[0];
			const modRole = await createRole(harness, owner.token, guild.id, {
				name: 'Moderator',
				permissions: Permissions.KICK_MEMBERS.toString(),
			});
			await addMemberRole(harness, owner.token, guild.id, member.userId, modRole.id);
			await createBuilder(harness, member.token)
				.delete(`/guilds/${guild.id}/members/${member.userId}`)
				.expect(HTTP_STATUS.NOT_FOUND)
				.execute();
		});
	});
	describe('Voice Mute and Deafen Permission Checks', () => {
		test('should not allow member with MUTE_MEMBERS only to deafen a member', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 2);
			const [moderator, target] = members;
			const modRole = await createRole(harness, owner.token, guild.id, {
				name: 'Muter',
				permissions: Permissions.MUTE_MEMBERS.toString(),
			});
			await addMemberRole(harness, owner.token, guild.id, moderator.userId, modRole.id);
			await createBuilder(harness, moderator.token)
				.patch(`/guilds/${guild.id}/members/${target.userId}`)
				.body({deaf: true})
				.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.MISSING_PERMISSIONS)
				.execute();
		});
		test('should not allow member with DEAFEN_MEMBERS only to mute a member', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 2);
			const [moderator, target] = members;
			const modRole = await createRole(harness, owner.token, guild.id, {
				name: 'Deafener',
				permissions: Permissions.DEAFEN_MEMBERS.toString(),
			});
			await addMemberRole(harness, owner.token, guild.id, moderator.userId, modRole.id);
			await createBuilder(harness, moderator.token)
				.patch(`/guilds/${guild.id}/members/${target.userId}`)
				.body({mute: true})
				.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.MISSING_PERMISSIONS)
				.execute();
		});
	});
	describe('Member Avatar Upload Validation', () => {
		test('should reject member avatar upload without premium', async () => {
			const {members, guild} = await setupTestGuildWithMembers(harness, 1);
			const member = members[0];
			await ensureSessionStarted(harness, member.token);
			const memberInfo = await createBuilder<GuildMemberResponse>(harness, member.token)
				.patch(`/guilds/${guild.id}/members/@me`)
				.body({avatar: getPngDataUrl()})
				.expect(HTTP_STATUS.OK)
				.execute();
			expect(memberInfo.avatar).toBeNull();
		});
	});
	describe('Member Banner Upload Validation', () => {
		test('should reject member banner upload without premium', async () => {
			const {members, guild} = await setupTestGuildWithMembers(harness, 1);
			const member = members[0];
			await ensureSessionStarted(harness, member.token);
			const memberInfo = await createBuilder<GuildMemberResponse>(harness, member.token)
				.patch(`/guilds/${guild.id}/members/@me`)
				.body({banner: getPngDataUrl()})
				.expect(HTTP_STATUS.OK)
				.execute();
			expect(memberInfo.banner).toBeNull();
		});
	});
	describe('Member Role Assignment/Removal', () => {
		test('should not allow removing role higher than own highest role', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 2);
			const [moderator, target] = members;
			const highRole = await createRole(harness, owner.token, guild.id, {
				name: 'High Role',
				permissions: '0',
			});
			const modRole = await createRole(harness, owner.token, guild.id, {
				name: 'Moderator',
				permissions: '268435456',
			});
			await updateRolePositions(harness, owner.token, guild.id, [
				{id: highRole.id, position: 3},
				{id: modRole.id, position: 2},
			]);
			await updateMember(harness, owner.token, guild.id, moderator.userId, {
				roles: [modRole.id],
			});
			await updateMember(harness, owner.token, guild.id, target.userId, {
				roles: [highRole.id],
			});
			await createBuilder(harness, moderator.token)
				.delete(`/guilds/${guild.id}/members/${target.userId}/roles/${highRole.id}`)
				.expect(HTTP_STATUS.FORBIDDEN)
				.execute();
		});
		test('should not allow member without MANAGE_ROLES to remove roles', async () => {
			const {owner, members, guild} = await setupTestGuildWithMembers(harness, 2);
			const [member1, member2] = members;
			const role = await createRole(harness, owner.token, guild.id, {
				name: 'Test Role',
			});
			await addMemberRole(harness, owner.token, guild.id, member2.userId, role.id);
			await createBuilder(harness, member1.token)
				.delete(`/guilds/${guild.id}/members/${member2.userId}/roles/${role.id}`)
				.expect(HTTP_STATUS.FORBIDDEN)
				.execute();
		});
	});
});