mirror of
https://github.com/discordjs/discord.js.git
synced 2026-03-09 16:13:31 +01:00
396 lines
10 KiB
TypeScript
396 lines
10 KiB
TypeScript
import type {
|
|
APIBan,
|
|
APIEmoji,
|
|
APIGuild,
|
|
APIGuildMember,
|
|
APIGuildWelcomeScreen,
|
|
APIGuildWelcomeScreenChannel,
|
|
APIRole,
|
|
APIRoleTags,
|
|
} from 'discord-api-types/v10';
|
|
import {
|
|
GuildDefaultMessageNotifications,
|
|
GuildExplicitContentFilter,
|
|
GuildFeature,
|
|
GuildMFALevel,
|
|
GuildNSFWLevel,
|
|
GuildPremiumTier,
|
|
GuildSystemChannelFlags,
|
|
GuildVerificationLevel,
|
|
} from 'discord-api-types/v10';
|
|
import { describe, expect, test } from 'vitest';
|
|
import {
|
|
Guild,
|
|
GuildBan,
|
|
GuildEmoji,
|
|
GuildMember,
|
|
Role,
|
|
RoleTags,
|
|
WelcomeChannel,
|
|
WelcomeScreen,
|
|
} from '../src/guilds/index.js';
|
|
import { kData } from '../src/utils/symbols.js';
|
|
|
|
describe('Guild', () => {
|
|
const data: Partial<APIGuild> = {
|
|
id: '123456789',
|
|
name: 'Test Guild',
|
|
icon: 'icon_hash',
|
|
splash: 'splash_hash',
|
|
discovery_splash: 'discovery_splash_hash',
|
|
owner_id: '987654321',
|
|
afk_channel_id: '111111111',
|
|
afk_timeout: 300,
|
|
widget_enabled: true,
|
|
widget_channel_id: '222222222',
|
|
verification_level: GuildVerificationLevel.Medium,
|
|
default_message_notifications: GuildDefaultMessageNotifications.OnlyMentions,
|
|
explicit_content_filter: GuildExplicitContentFilter.AllMembers,
|
|
roles: [],
|
|
emojis: [],
|
|
features: [GuildFeature.Community, GuildFeature.Discoverable],
|
|
mfa_level: GuildMFALevel.Elevated,
|
|
application_id: null,
|
|
system_channel_id: '333333333',
|
|
system_channel_flags: GuildSystemChannelFlags.SuppressJoinNotifications,
|
|
rules_channel_id: '444444444',
|
|
max_presences: null,
|
|
max_members: 500_000,
|
|
vanity_url_code: 'testguild',
|
|
description: 'A test guild',
|
|
banner: 'banner_hash',
|
|
premium_tier: GuildPremiumTier.Tier2,
|
|
premium_subscription_count: 7,
|
|
preferred_locale: 'en-US' as any,
|
|
public_updates_channel_id: '555555555',
|
|
max_video_channel_users: 25,
|
|
max_stage_video_channel_users: 50,
|
|
approximate_member_count: 1000,
|
|
approximate_presence_count: 250,
|
|
nsfw_level: GuildNSFWLevel.Default,
|
|
stickers: [],
|
|
premium_progress_bar_enabled: true,
|
|
safety_alerts_channel_id: '666666666',
|
|
};
|
|
|
|
// @ts-expect-error Guild constructor is protected
|
|
const guild = new Guild(data as APIGuild);
|
|
|
|
test('should have correct id', () => {
|
|
expect(guild.id).toBe('123456789');
|
|
});
|
|
|
|
test('should have correct name', () => {
|
|
expect(guild.name).toBe('Test Guild');
|
|
});
|
|
|
|
test('should have correct icon', () => {
|
|
expect(guild.icon).toBe('icon_hash');
|
|
});
|
|
|
|
test('should have correct ownerId', () => {
|
|
expect(guild.ownerId).toBe('987654321');
|
|
});
|
|
|
|
test('should have correct features', () => {
|
|
expect(guild.features).toEqual([GuildFeature.Community, GuildFeature.Discoverable]);
|
|
});
|
|
|
|
test('should have correct verificationLevel', () => {
|
|
expect(guild.verificationLevel).toBe(GuildVerificationLevel.Medium);
|
|
});
|
|
|
|
test('should have correct premiumTier', () => {
|
|
expect(guild.premiumTier).toBe(GuildPremiumTier.Tier2);
|
|
});
|
|
|
|
test('should have correct vanityUrlCode', () => {
|
|
expect(guild.vanityUrlCode).toBe('testguild');
|
|
});
|
|
|
|
test('should store data in kData', () => {
|
|
expect(guild[kData]).toBeDefined();
|
|
expect(guild[kData].id).toBe('123456789');
|
|
});
|
|
});
|
|
|
|
describe('GuildMember', () => {
|
|
const data: APIGuildMember = {
|
|
user: { id: '123', username: 'testuser', discriminator: '0', global_name: null, avatar: null },
|
|
nick: 'TestNick',
|
|
avatar: 'member_avatar_hash',
|
|
roles: ['456', '789'],
|
|
joined_at: '2023-01-15T10:30:00.000000+00:00',
|
|
premium_since: '2023-06-01T12:00:00.000000+00:00',
|
|
deaf: false,
|
|
mute: false,
|
|
flags: 0 as any,
|
|
pending: false,
|
|
communication_disabled_until: '2024-12-31T23:59:59.000000+00:00',
|
|
};
|
|
|
|
// @ts-expect-error GuildMember constructor is protected
|
|
const member = new GuildMember(data);
|
|
|
|
test('should have correct userId', () => {
|
|
expect(member.userId).toBe('123');
|
|
});
|
|
|
|
test('should have correct nick', () => {
|
|
expect(member.nick).toBe('TestNick');
|
|
});
|
|
|
|
test('should have correct avatar', () => {
|
|
expect(member.avatar).toBe('member_avatar_hash');
|
|
});
|
|
|
|
test('should have correct roles', () => {
|
|
expect(member.roles).toEqual(['456', '789']);
|
|
});
|
|
|
|
test('should have correct flags', () => {
|
|
expect(member.flags).toBe(0);
|
|
});
|
|
|
|
test('should have correct permissions when provided', () => {
|
|
expect(member.permissions).toBeUndefined();
|
|
});
|
|
|
|
test('should optimize joined_at to timestamp', () => {
|
|
expect(member.joinedTimestamp).toBeTypeOf('number');
|
|
expect(member.joinedTimestamp).toBeGreaterThan(0);
|
|
});
|
|
|
|
test('should convert joinedTimestamp to Date', () => {
|
|
const joinedAt = member.joinedAt;
|
|
expect(joinedAt).toBeInstanceOf(Date);
|
|
expect(joinedAt?.getFullYear()).toBe(2023);
|
|
});
|
|
|
|
test('should optimize premium_since to timestamp', () => {
|
|
expect(member.premiumSinceTimestamp).toBeTypeOf('number');
|
|
expect(member.premiumSinceTimestamp).toBeGreaterThan(0);
|
|
});
|
|
|
|
test('should optimize communication_disabled_until to timestamp', () => {
|
|
expect(member.communicationDisabledUntilTimestamp).toBeTypeOf('number');
|
|
expect(member.communicationDisabledUntilTimestamp).toBeGreaterThan(0);
|
|
});
|
|
|
|
test('should correctly identify if communication is disabled', () => {
|
|
// The timestamp is in the future (2024-12-31), so it should be disabled
|
|
// But we're testing in 2025, so let's check the behavior
|
|
expect(typeof member.isCommunicationDisabled).toBe('boolean');
|
|
});
|
|
|
|
test('should convert to JSON with ISO timestamps', () => {
|
|
const json = member.toJSON();
|
|
expect(json.joined_at).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}\+00:00$/);
|
|
expect(json.premium_since).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}\+00:00$/);
|
|
expect(json.communication_disabled_until).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}\+00:00$/);
|
|
});
|
|
});
|
|
|
|
describe('Role', () => {
|
|
const data: APIRole = {
|
|
id: '999',
|
|
name: 'Admin',
|
|
color: 0xff_00_00,
|
|
hoist: true,
|
|
icon: null,
|
|
unicode_emoji: null,
|
|
position: 10,
|
|
permissions: '8',
|
|
managed: false,
|
|
mentionable: true,
|
|
flags: 0 as any,
|
|
};
|
|
|
|
// @ts-expect-error Role constructor is protected
|
|
const role = new Role(data);
|
|
|
|
test('should have correct id', () => {
|
|
expect(role.id).toBe('999');
|
|
});
|
|
|
|
test('should have correct name', () => {
|
|
expect(role.name).toBe('Admin');
|
|
});
|
|
|
|
test('should have correct color', () => {
|
|
expect(role.color).toBe(0xff_00_00);
|
|
});
|
|
|
|
test('should have correct hexColor', () => {
|
|
expect(role.hexColor).toBe('#ff0000');
|
|
});
|
|
|
|
test('should have correct hoist', () => {
|
|
expect(role.hoist).toBe(true);
|
|
});
|
|
|
|
test('should have correct position', () => {
|
|
expect(role.position).toBe(10);
|
|
});
|
|
|
|
test('should have correct permissions', () => {
|
|
expect(role.permissions).toBe('8');
|
|
});
|
|
|
|
test('should have correct managed status', () => {
|
|
expect(role.managed).toBe(false);
|
|
});
|
|
|
|
test('should have correct mentionable status', () => {
|
|
expect(role.mentionable).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('RoleTags', () => {
|
|
test('should handle bot role tags', () => {
|
|
const data: APIRoleTags = { bot_id: '123456' };
|
|
const tags = new RoleTags(data);
|
|
|
|
expect(tags.botId).toBe('123456');
|
|
expect(tags.integrationId).toBeUndefined();
|
|
expect(tags.premiumSubscriber).toBe(false);
|
|
});
|
|
|
|
test('should handle premium subscriber role tags', () => {
|
|
const data: APIRoleTags = { premium_subscriber: null };
|
|
const tags = new RoleTags(data);
|
|
|
|
expect(tags.premiumSubscriber).toBe(true);
|
|
expect(tags.botId).toBeUndefined();
|
|
});
|
|
|
|
test('should handle integration role tags', () => {
|
|
const data: APIRoleTags = { integration_id: '789012' };
|
|
const tags = new RoleTags(data);
|
|
|
|
expect(tags.integrationId).toBe('789012');
|
|
expect(tags.premiumSubscriber).toBe(false);
|
|
});
|
|
|
|
test('should handle available for purchase tags', () => {
|
|
const data: APIRoleTags = { available_for_purchase: null };
|
|
const tags = new RoleTags(data);
|
|
|
|
expect(tags.availableForPurchase).toBe(true);
|
|
});
|
|
|
|
test('should handle guild connections tags', () => {
|
|
const data: APIRoleTags = { guild_connections: null };
|
|
const tags = new RoleTags(data);
|
|
|
|
expect(tags.guildConnections).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('GuildEmoji', () => {
|
|
const data: APIEmoji = {
|
|
id: '555',
|
|
name: 'test_emoji',
|
|
roles: ['123', '456'],
|
|
require_colons: true,
|
|
managed: false,
|
|
animated: true,
|
|
available: true,
|
|
};
|
|
|
|
// @ts-expect-error GuildEmoji constructor is protected
|
|
const emoji = new GuildEmoji(data);
|
|
|
|
test('should have correct id', () => {
|
|
expect(emoji.id).toBe('555');
|
|
});
|
|
|
|
test('should have correct name', () => {
|
|
expect(emoji.name).toBe('test_emoji');
|
|
});
|
|
|
|
test('should have correct roles', () => {
|
|
expect(emoji.roles).toEqual(['123', '456']);
|
|
});
|
|
|
|
test('should have correct requireColons', () => {
|
|
expect(emoji.requireColons).toBe(true);
|
|
});
|
|
|
|
test('should have correct managed status', () => {
|
|
expect(emoji.managed).toBe(false);
|
|
});
|
|
|
|
test('should have correct animated status', () => {
|
|
expect(emoji.animated).toBe(true);
|
|
});
|
|
|
|
test('should have correct available status', () => {
|
|
expect(emoji.available).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('GuildBan', () => {
|
|
const data: APIBan = {
|
|
reason: 'Spam',
|
|
user: { id: '111', username: 'banneduser', discriminator: '0', global_name: null, avatar: null },
|
|
};
|
|
|
|
// @ts-expect-error GuildBan constructor is protected
|
|
const ban = new GuildBan(data);
|
|
|
|
test('should have correct reason', () => {
|
|
expect(ban.reason).toBe('Spam');
|
|
});
|
|
|
|
test('should store data in kData', () => {
|
|
expect(ban[kData].user).toBeDefined();
|
|
expect(ban[kData].user.id).toBe('111');
|
|
});
|
|
});
|
|
|
|
describe('WelcomeChannel', () => {
|
|
const data: APIGuildWelcomeScreenChannel = {
|
|
channel_id: '888',
|
|
description: 'Read the rules',
|
|
emoji_id: '999',
|
|
emoji_name: '📜',
|
|
};
|
|
|
|
const channel = new WelcomeChannel(data);
|
|
|
|
test('should have correct channelId', () => {
|
|
expect(channel.channelId).toBe('888');
|
|
});
|
|
|
|
test('should have correct description', () => {
|
|
expect(channel.description).toBe('Read the rules');
|
|
});
|
|
|
|
test('should have correct emojiId', () => {
|
|
expect(channel.emojiId).toBe('999');
|
|
});
|
|
|
|
test('should have correct emojiName', () => {
|
|
expect(channel.emojiName).toBe('📜');
|
|
});
|
|
});
|
|
|
|
describe('WelcomeScreen', () => {
|
|
const data: APIGuildWelcomeScreen = {
|
|
description: 'Welcome to our server!',
|
|
welcome_channels: [],
|
|
};
|
|
|
|
// @ts-expect-error WelcomeScreen constructor is protected
|
|
const screen = new WelcomeScreen(data);
|
|
|
|
test('should have correct description', () => {
|
|
expect(screen.description).toBe('Welcome to our server!');
|
|
});
|
|
|
|
test('should store data in kData', () => {
|
|
expect(screen[kData].welcome_channels).toEqual([]);
|
|
});
|
|
});
|