Skip to content

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

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

import {
	addMemberRole,
	createChannel,
	createPermissionOverwrite,
	createRole,
	setupTestGuildWithMembers,
} from '@app/api/channel/tests/ChannelTestUtils';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {setLimitOverride} from '@app/api/test/LimitTestUtils';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';
import {ChannelTypes, Permissions} from '@fluxer/constants/src/ChannelConstants';
import type {ChannelResponse} from '@fluxer/schema/src/domains/channel/ChannelSchemas';
import {beforeAll, beforeEach, describe, expect, it} from 'vitest';

describe('Channel create in a category', () => {
	let harness: ApiTestHarness;
	beforeAll(async () => {
		harness = await createApiTestHarness();
	});
	beforeEach(async () => {
		await harness.reset();
	});

	async function setupCategoryManager(extraAllow = 0n) {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const category = await createChannel(harness, owner.token, guild.id, 'managed', ChannelTypes.GUILD_CATEGORY);
		const otherCategory = await createChannel(harness, owner.token, guild.id, 'other', ChannelTypes.GUILD_CATEGORY);
		const role = await createRole(harness, owner.token, guild.id, {name: 'creators'});
		await addMemberRole(harness, owner.token, guild.id, member.userId, role.id);
		await createPermissionOverwrite(harness, owner.token, category.id, role.id, {
			type: 0,
			allow: (Permissions.VIEW_CHANNEL | Permissions.MANAGE_CHANNELS | extraAllow).toString(),
			deny: '0',
		});
		return {owner, member, guild, role, category, otherCategory};
	}

	it('lets a category overwrite grant MANAGE_CHANNELS for that category only', async () => {
		const {member, guild, category, otherCategory} = await setupCategoryManager();
		const created = await createBuilder<ChannelResponse>(harness, member.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({name: 'member-made', type: ChannelTypes.GUILD_TEXT, parent_id: category.id})
			.execute();
		expect(created.parent_id).toBe(category.id);
		await createBuilder(harness, member.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({name: 'root-made', type: ChannelTypes.GUILD_TEXT})
			.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.MISSING_PERMISSIONS)
			.execute();
		await createBuilder(harness, member.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({name: 'elsewhere', type: ChannelTypes.GUILD_TEXT, parent_id: otherCategory.id})
			.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.MISSING_PERMISSIONS)
			.execute();
	});

	it('honors a category deny of MANAGE_CHANNELS for a guild-wide manager', async () => {
		const {owner, members, guild} = await setupTestGuildWithMembers(harness, 1);
		const member = members[0];
		const category = await createChannel(harness, owner.token, guild.id, 'locked', ChannelTypes.GUILD_CATEGORY);
		const role = await createRole(harness, owner.token, guild.id, {
			name: 'managers',
			permissions: Permissions.MANAGE_CHANNELS.toString(),
		});
		await addMemberRole(harness, owner.token, guild.id, member.userId, role.id);
		await createPermissionOverwrite(harness, owner.token, category.id, role.id, {
			type: 0,
			allow: '0',
			deny: Permissions.MANAGE_CHANNELS.toString(),
		});
		await createBuilder(harness, member.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({name: 'denied', type: ChannelTypes.GUILD_TEXT, parent_id: category.id})
			.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.MISSING_PERMISSIONS)
			.execute();
	});

	it('lets a category overwrite grant MANAGE_ROLES for requested overwrites within its own permissions', async () => {
		const {member, guild, role, category} = await setupCategoryManager(Permissions.MANAGE_ROLES);
		await createBuilder<ChannelResponse>(harness, member.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({
				name: 'with-overwrites',
				type: ChannelTypes.GUILD_TEXT,
				parent_id: category.id,
				permission_overwrites: [{id: role.id, type: 0, allow: Permissions.VIEW_CHANNEL.toString(), deny: '0'}],
			})
			.execute();
		await createBuilder(harness, member.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({
				name: 'escalate',
				type: ChannelTypes.GUILD_TEXT,
				parent_id: category.id,
				permission_overwrites: [{id: role.id, type: 0, allow: Permissions.ADMINISTRATOR.toString(), deny: '0'}],
			})
			.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.MISSING_PERMISSIONS)
			.execute();
	});

	it('rejects requested overwrites without MANAGE_ROLES on the category', async () => {
		const {member, guild, role, category} = await setupCategoryManager();
		await createBuilder(harness, member.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({
				name: 'no-roles',
				type: ChannelTypes.GUILD_TEXT,
				parent_id: category.id,
				permission_overwrites: [{id: role.id, type: 0, allow: Permissions.VIEW_CHANNEL.toString(), deny: '0'}],
			})
			.expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.MISSING_PERMISSIONS)
			.execute();
	});

	it('applies a configured max_channels_per_category on create', async () => {
		const {owner, guild} = await setupTestGuildWithMembers(harness, 0);
		const category = await createChannel(harness, owner.token, guild.id, 'full', ChannelTypes.GUILD_CATEGORY);
		const restore = await setLimitOverride(harness, {max_channels_per_category: 0});
		try {
			await createBuilder(harness, owner.token)
				.post(`/guilds/${guild.id}/channels`)
				.body({name: 'overflow', type: ChannelTypes.GUILD_TEXT, parent_id: category.id})
				.expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.MAX_CATEGORY_CHANNELS)
				.execute();
			await createChannel(harness, owner.token, guild.id, 'at-root');
		} finally {
			await restore();
		}
	});

	it('applies a configured max_guild_channels on create', async () => {
		const {owner, guild} = await setupTestGuildWithMembers(harness, 0);
		const restore = await setLimitOverride(harness, {max_guild_channels: 0});
		try {
			await createBuilder(harness, owner.token)
				.post(`/guilds/${guild.id}/channels`)
				.body({name: 'overflow', type: ChannelTypes.GUILD_TEXT})
				.expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.MAX_GUILD_CHANNELS)
				.execute();
		} finally {
			await restore();
		}
	});

	it('applies a configured max_channels_per_category when a channel is moved into a category', async () => {
		const {owner, guild} = await setupTestGuildWithMembers(harness, 0);
		const category = await createChannel(harness, owner.token, guild.id, 'target', ChannelTypes.GUILD_CATEGORY);
		const channel = await createChannel(harness, owner.token, guild.id, 'mover');
		const move = () =>
			createBuilder(harness, owner.token)
				.patch(`/guilds/${guild.id}/channels`)
				.body([{id: channel.id, parent_id: category.id}]);
		const restore = await setLimitOverride(harness, {max_channels_per_category: 0});
		try {
			await move().expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.MAX_CATEGORY_CHANNELS).execute();
		} finally {
			await restore();
		}
		await move().expect(HTTP_STATUS.NO_CONTENT).execute();
		const moved = await createBuilder<ChannelResponse>(harness, owner.token).get(`/channels/${channel.id}`).execute();
		expect(moved.parent_id).toBe(category.id);
	});
});