660 lines
24 KiB
TypeScript
660 lines
24 KiB
TypeScript
/*
|
|
* Copyright (C) 2026 Fluxer Contributors
|
|
*
|
|
* This file is part of Fluxer.
|
|
*
|
|
* Fluxer is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Fluxer is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import {createTestAccount} from '@fluxer/api/src/auth/tests/AuthTestUtils';
|
|
import {
|
|
createChannel,
|
|
createRole,
|
|
getChannel,
|
|
setupTestGuildWithMembers,
|
|
updateChannel,
|
|
} from '@fluxer/api/src/channel/tests/ChannelTestUtils';
|
|
import {createGuild, getGuildChannels} from '@fluxer/api/src/guild/tests/GuildTestUtils';
|
|
import {type ApiTestHarness, createApiTestHarness} from '@fluxer/api/src/test/ApiTestHarness';
|
|
import {HTTP_STATUS} from '@fluxer/api/src/test/TestConstants';
|
|
import {createBuilder} from '@fluxer/api/src/test/TestRequestBuilder';
|
|
import {ChannelTypes, Permissions} from '@fluxer/constants/src/ChannelConstants';
|
|
import type {ChannelResponse} from '@fluxer/schema/src/domains/channel/ChannelSchemas';
|
|
import {afterEach, beforeEach, describe, expect, test} from 'vitest';
|
|
|
|
describe('Guild Channel Management', () => {
|
|
let harness: ApiTestHarness;
|
|
|
|
beforeEach(async () => {
|
|
harness = await createApiTestHarness();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await harness?.shutdown();
|
|
});
|
|
|
|
describe('Channel Name Updates', () => {
|
|
test('should normalize channel name with spaces to hyphens', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const updated = await updateChannel(harness, account.token, channel.id, {name: 'my new channel'});
|
|
|
|
expect(updated.name).toBe('my-new-channel');
|
|
});
|
|
|
|
test('should reject channel name exceeding maximum length', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const longName = 'a'.repeat(101);
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${channel.id}`)
|
|
.body({name: longName, type: ChannelTypes.GUILD_TEXT})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should preserve channel name when update name is empty', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const updated = await updateChannel(harness, account.token, channel.id, {name: ''});
|
|
|
|
expect(updated.name).toBe('test-channel');
|
|
});
|
|
|
|
test('should convert channel name to lowercase', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const updated = await updateChannel(harness, account.token, channel.id, {name: 'MyChannel'});
|
|
|
|
expect(updated.name).toBe('mychannel');
|
|
});
|
|
});
|
|
|
|
describe('Channel Topic Updates', () => {
|
|
test('should allow clearing channel topic', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
await updateChannel(harness, account.token, channel.id, {topic: 'Initial topic'});
|
|
const updated = await updateChannel(harness, account.token, channel.id, {topic: null});
|
|
|
|
expect(updated.topic).toBeNull();
|
|
});
|
|
|
|
test('should reject channel topic exceeding maximum length', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const longTopic = 'a'.repeat(1025);
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${channel.id}`)
|
|
.body({topic: longTopic, type: ChannelTypes.GUILD_TEXT})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should accept topic at maximum length', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const maxTopic = 'a'.repeat(1024);
|
|
const updated = await updateChannel(harness, account.token, channel.id, {topic: maxTopic});
|
|
|
|
expect(updated.topic).toBe(maxTopic);
|
|
});
|
|
});
|
|
|
|
describe('Channel Slowmode (rate_limit_per_user)', () => {
|
|
test('should set slowmode on text channel', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const updated = await updateChannel(harness, account.token, channel.id, {rate_limit_per_user: 60});
|
|
|
|
expect(updated.rate_limit_per_user).toBe(60);
|
|
});
|
|
|
|
test('should disable slowmode by setting to zero', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
await updateChannel(harness, account.token, channel.id, {rate_limit_per_user: 60});
|
|
const updated = await updateChannel(harness, account.token, channel.id, {rate_limit_per_user: 0});
|
|
|
|
expect(updated.rate_limit_per_user).toBe(0);
|
|
});
|
|
|
|
test('should reject negative slowmode value', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${channel.id}`)
|
|
.body({rate_limit_per_user: -1, type: ChannelTypes.GUILD_TEXT})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should reject slowmode exceeding maximum (21600 seconds)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${channel.id}`)
|
|
.body({rate_limit_per_user: 21601, type: ChannelTypes.GUILD_TEXT})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should accept maximum slowmode value (21600 seconds)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
const updated = await updateChannel(harness, account.token, channel.id, {rate_limit_per_user: 21600});
|
|
|
|
expect(updated.rate_limit_per_user).toBe(21600);
|
|
});
|
|
});
|
|
|
|
describe('Channel Position Updates', () => {
|
|
test('should update single channel position via direct PATCH', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
|
|
await createChannel(harness, account.token, guild.id, 'channel-1');
|
|
const channel2 = await createChannel(harness, account.token, guild.id, 'channel-2');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/guilds/${guild.id}/channels`)
|
|
.body([{id: channel2.id, position: 0}])
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const channels = await getGuildChannels(harness, account.token, guild.id);
|
|
const updatedChannel2 = channels.find((c) => c.id === channel2.id);
|
|
expect(updatedChannel2).toBeDefined();
|
|
});
|
|
|
|
test('should update multiple channel positions in bulk via direct PATCH', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
|
|
const channel1 = await createChannel(harness, account.token, guild.id, 'channel-1');
|
|
const channel2 = await createChannel(harness, account.token, guild.id, 'channel-2');
|
|
const channel3 = await createChannel(harness, account.token, guild.id, 'channel-3');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/guilds/${guild.id}/channels`)
|
|
.body([
|
|
{id: channel3.id, position: 0},
|
|
{id: channel2.id, position: 1},
|
|
{id: channel1.id, position: 2},
|
|
])
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const channels = await getGuildChannels(harness, account.token, guild.id);
|
|
const textChannels = channels.filter((c) => c.type === ChannelTypes.GUILD_TEXT);
|
|
|
|
expect(textChannels.some((c) => c.id === channel1.id)).toBe(true);
|
|
expect(textChannels.some((c) => c.id === channel2.id)).toBe(true);
|
|
expect(textChannels.some((c) => c.id === channel3.id)).toBe(true);
|
|
});
|
|
|
|
test('should move channel into category via direct PATCH', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
|
|
const category = await createChannel(harness, account.token, guild.id, 'Category', ChannelTypes.GUILD_CATEGORY);
|
|
const textChannel = await createChannel(harness, account.token, guild.id, 'text-channel');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/guilds/${guild.id}/channels`)
|
|
.body([{id: textChannel.id, parent_id: category.id}])
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const updatedChannel = await getChannel(harness, account.token, textChannel.id);
|
|
expect(updatedChannel.parent_id).toBe(category.id);
|
|
});
|
|
|
|
test('should move channel out of category via direct PATCH', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
|
|
const category = await createChannel(harness, account.token, guild.id, 'Category', ChannelTypes.GUILD_CATEGORY);
|
|
const textChannel = await createChannel(harness, account.token, guild.id, 'text-channel');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/guilds/${guild.id}/channels`)
|
|
.body([{id: textChannel.id, parent_id: category.id}])
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
let updatedChannel = await getChannel(harness, account.token, textChannel.id);
|
|
expect(updatedChannel.parent_id).toBe(category.id);
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/guilds/${guild.id}/channels`)
|
|
.body([{id: textChannel.id, parent_id: null}])
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
updatedChannel = await getChannel(harness, account.token, textChannel.id);
|
|
expect(updatedChannel.parent_id).toBeNull();
|
|
});
|
|
|
|
test('should lock permissions when moving to category via direct PATCH', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
|
|
const category = await createChannel(harness, account.token, guild.id, 'Category', ChannelTypes.GUILD_CATEGORY);
|
|
const textChannel = await createChannel(harness, account.token, guild.id, 'text-channel');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/guilds/${guild.id}/channels`)
|
|
.body([{id: textChannel.id, parent_id: category.id, lock_permissions: true}])
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const updatedChannel = await getChannel(harness, account.token, textChannel.id);
|
|
expect(updatedChannel.parent_id).toBe(category.id);
|
|
});
|
|
|
|
test('should reject or forbid invalid channel id in position update', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/guilds/${guild.id}/channels`)
|
|
.body([{id: '999999999999999999', position: 0}])
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
});
|
|
|
|
describe('Channel Permission Overwrites Operations', () => {
|
|
test('should create permission overwrite for role', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
const role = await createRole(harness, account.token, guild.id, {name: 'Test Role'});
|
|
|
|
await createBuilder(harness, account.token)
|
|
.put(`/channels/${channel.id}/permissions/${role.id}`)
|
|
.body({
|
|
type: 0,
|
|
allow: Permissions.SEND_MESSAGES.toString(),
|
|
deny: '0',
|
|
})
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const channelData = await getChannel(harness, account.token, channel.id);
|
|
const overwrite = channelData.permission_overwrites?.find((o) => o.id === role.id);
|
|
expect(overwrite).toBeDefined();
|
|
expect(overwrite?.type).toBe(0);
|
|
});
|
|
|
|
test('should create permission overwrite for member', async () => {
|
|
const {owner, members, systemChannel} = await setupTestGuildWithMembers(harness, 1);
|
|
const member = members[0];
|
|
|
|
await createBuilder(harness, owner.token)
|
|
.put(`/channels/${systemChannel.id}/permissions/${member.userId}`)
|
|
.body({
|
|
type: 1,
|
|
allow: Permissions.VIEW_CHANNEL.toString(),
|
|
deny: Permissions.SEND_MESSAGES.toString(),
|
|
})
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const channelData = await getChannel(harness, owner.token, systemChannel.id);
|
|
const overwrite = channelData.permission_overwrites?.find((o) => o.id === member.userId);
|
|
expect(overwrite).toBeDefined();
|
|
expect(overwrite?.type).toBe(1);
|
|
});
|
|
|
|
test('should update existing permission overwrite', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
const role = await createRole(harness, account.token, guild.id, {name: 'Test Role'});
|
|
|
|
await createBuilder(harness, account.token)
|
|
.put(`/channels/${channel.id}/permissions/${role.id}`)
|
|
.body({
|
|
type: 0,
|
|
allow: Permissions.SEND_MESSAGES.toString(),
|
|
deny: '0',
|
|
})
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
await createBuilder(harness, account.token)
|
|
.put(`/channels/${channel.id}/permissions/${role.id}`)
|
|
.body({
|
|
type: 0,
|
|
allow: (Permissions.SEND_MESSAGES | Permissions.EMBED_LINKS).toString(),
|
|
deny: '0',
|
|
})
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const channelData = await getChannel(harness, account.token, channel.id);
|
|
const overwrite = channelData.permission_overwrites?.find((o) => o.id === role.id);
|
|
expect(BigInt(overwrite!.allow)).toBe(Permissions.SEND_MESSAGES | Permissions.EMBED_LINKS);
|
|
});
|
|
|
|
test('should delete permission overwrite', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
const role = await createRole(harness, account.token, guild.id, {name: 'Test Role'});
|
|
|
|
await createBuilder(harness, account.token)
|
|
.put(`/channels/${channel.id}/permissions/${role.id}`)
|
|
.body({
|
|
type: 0,
|
|
allow: Permissions.SEND_MESSAGES.toString(),
|
|
deny: '0',
|
|
})
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
await createBuilder(harness, account.token)
|
|
.delete(`/channels/${channel.id}/permissions/${role.id}`)
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const channelData = await getChannel(harness, account.token, channel.id);
|
|
const overwrite = channelData.permission_overwrites?.find((o) => o.id === role.id);
|
|
expect(overwrite).toBeUndefined();
|
|
});
|
|
|
|
test('should show overwrites in channel response', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
const role = await createRole(harness, account.token, guild.id, {name: 'Test Role'});
|
|
|
|
await createBuilder(harness, account.token)
|
|
.put(`/channels/${channel.id}/permissions/${role.id}`)
|
|
.body({
|
|
type: 0,
|
|
allow: Permissions.SEND_MESSAGES.toString(),
|
|
deny: '0',
|
|
})
|
|
.expect(HTTP_STATUS.NO_CONTENT)
|
|
.execute();
|
|
|
|
const channelData = await getChannel(harness, account.token, channel.id);
|
|
expect(channelData.permission_overwrites).toBeDefined();
|
|
expect(channelData.permission_overwrites?.some((o) => o.id === role.id)).toBe(true);
|
|
});
|
|
|
|
test('should reject invalid overwrite type', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const channel = await createChannel(harness, account.token, guild.id, 'test-channel');
|
|
|
|
await createBuilder(harness, account.token)
|
|
.put(`/channels/${channel.id}/permissions/123456789`)
|
|
.body({
|
|
type: 999,
|
|
allow: '0',
|
|
deny: '0',
|
|
})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should require MANAGE_ROLES permission to create overwrites', async () => {
|
|
const {owner, members, guild, systemChannel} = await setupTestGuildWithMembers(harness, 1);
|
|
const member = members[0];
|
|
const role = await createRole(harness, owner.token, guild.id, {name: 'Test Role'});
|
|
|
|
await createBuilder(harness, member.token)
|
|
.put(`/channels/${systemChannel.id}/permissions/${role.id}`)
|
|
.body({
|
|
type: 0,
|
|
allow: Permissions.SEND_MESSAGES.toString(),
|
|
deny: '0',
|
|
})
|
|
.expect(HTTP_STATUS.FORBIDDEN)
|
|
.execute();
|
|
});
|
|
});
|
|
|
|
describe('Voice Channel Bitrate and User Limit Updates', () => {
|
|
test('should update voice channel bitrate', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
const data = await createBuilder<ChannelResponse>(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, bitrate: 96000})
|
|
.execute();
|
|
expect(data.bitrate).toBe(96000);
|
|
});
|
|
|
|
test('should update voice channel user limit', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
const data = await createBuilder<ChannelResponse>(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, user_limit: 10})
|
|
.execute();
|
|
expect(data.user_limit).toBe(10);
|
|
});
|
|
|
|
test('should set unlimited user capacity with zero', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
const data = await createBuilder<ChannelResponse>(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, user_limit: 0})
|
|
.execute();
|
|
expect(data.user_limit).toBe(0);
|
|
});
|
|
|
|
test('should reject bitrate below minimum (8000)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, bitrate: 7999})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should reject bitrate above maximum (320000)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, bitrate: 320001})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should reject negative user limit', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, user_limit: -1})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should reject user limit above maximum (99)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
await createBuilder(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, user_limit: 100})
|
|
.expect(HTTP_STATUS.BAD_REQUEST)
|
|
.execute();
|
|
});
|
|
|
|
test('should accept minimum bitrate (8000)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
const data = await createBuilder<ChannelResponse>(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, bitrate: 8000})
|
|
.execute();
|
|
expect(data.bitrate).toBe(8000);
|
|
});
|
|
|
|
test('should accept maximum bitrate (320000)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
const data = await createBuilder<ChannelResponse>(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, bitrate: 320000})
|
|
.execute();
|
|
expect(data.bitrate).toBe(320000);
|
|
});
|
|
|
|
test('should accept maximum user limit (99)', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
const data = await createBuilder<ChannelResponse>(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, user_limit: 99})
|
|
.execute();
|
|
expect(data.user_limit).toBe(99);
|
|
});
|
|
|
|
test('should update both bitrate and user limit together', async () => {
|
|
const account = await createTestAccount(harness);
|
|
const guild = await createGuild(harness, account.token, 'Test Guild');
|
|
const voiceChannel = await createChannel(
|
|
harness,
|
|
account.token,
|
|
guild.id,
|
|
'voice-channel',
|
|
ChannelTypes.GUILD_VOICE,
|
|
);
|
|
|
|
const data = await createBuilder<ChannelResponse>(harness, account.token)
|
|
.patch(`/channels/${voiceChannel.id}`)
|
|
.body({type: ChannelTypes.GUILD_VOICE, bitrate: 128000, user_limit: 25})
|
|
.execute();
|
|
expect(data.bitrate).toBe(128000);
|
|
expect(data.user_limit).toBe(25);
|
|
});
|
|
});
|
|
});
|