chore: monorepo setup (#7175)

2026-03-14 18:43:31 +01:00 · 2022-01-07 17:18:25 +01:00
parent 780b7ed39f
commit 16390efe6e
504 changed files with 25459 additions and 22830 deletions
--- a/packages/builders/tests/interactions/ContextMenuCommands.test.ts
+++ b/packages/builders/tests/interactions/ContextMenuCommands.test.ts
@@ -0,0 +1,89 @@
+import { ContextMenuCommandAssertions, ContextMenuCommandBuilder } from '../../src/index';
+
+const getBuilder = () => new ContextMenuCommandBuilder();
+
+describe('Context Menu Commands', () => {
+	describe('Assertions tests', () => {
+		test('GIVEN valid name THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateName('ping')).not.toThrowError();
+		});
+
+		test('GIVEN invalid name THEN throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateName(null)).toThrowError();
+
+			// Too short of a name
+			expect(() => ContextMenuCommandAssertions.validateName('')).toThrowError();
+
+			// Invalid characters used
+			expect(() => ContextMenuCommandAssertions.validateName('ABC123$%^&')).toThrowError();
+
+			// Too long of a name
+			expect(() =>
+				ContextMenuCommandAssertions.validateName('qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbnm'),
+			).toThrowError();
+		});
+
+		test('GIVEN valid type THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateType(3)).not.toThrowError();
+		});
+
+		test('GIVEN invalid type THEN throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateType(null)).toThrowError();
+
+			// Out of range
+			expect(() => ContextMenuCommandAssertions.validateType(1)).toThrowError();
+		});
+
+		test('GIVEN valid required parameters THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateRequiredParameters('owo', 2)).not.toThrowError();
+		});
+
+		test('GIVEN valid default_permission THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateDefaultPermission(true)).not.toThrowError();
+		});
+
+		test('GIVEN invalid default_permission THEN throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateDefaultPermission(null)).toThrowError();
+		});
+	});
+
+	describe('ContextMenuCommandBuilder', () => {
+		describe('Builder tests', () => {
+			test('GIVEN empty builder THEN throw error when calling toJSON', () => {
+				expect(() => getBuilder().toJSON()).toThrowError();
+			});
+
+			test('GIVEN valid builder THEN does not throw error', () => {
+				expect(() => getBuilder().setName('example').setType(3).toJSON()).not.toThrowError();
+			});
+
+			test('GIVEN invalid name THEN throw error', () => {
+				expect(() => getBuilder().setName('$$$')).toThrowError();
+
+				expect(() => getBuilder().setName(' ')).toThrowError();
+			});
+
+			test('GIVEN valid names THEN does not throw error', () => {
+				expect(() => getBuilder().setName('hi_there')).not.toThrowError();
+
+				expect(() => getBuilder().setName('A COMMAND')).not.toThrowError();
+
+				// Translation: a_command
+				expect(() => getBuilder().setName('o_comandă')).not.toThrowError();
+
+				// Translation: thx (according to GTranslate)
+				expect(() => getBuilder().setName('どうも')).not.toThrowError();
+			});
+
+			test('GIVEN valid types THEN does not throw error', () => {
+				expect(() => getBuilder().setType(2)).not.toThrowError();
+
+				expect(() => getBuilder().setType(3)).not.toThrowError();
+			});
+
+			test('GIVEN valid builder with defaultPermission false THEN does not throw error', () => {
+				expect(() => getBuilder().setName('foo').setDefaultPermission(false)).not.toThrowError();
+			});
+		});
+	});
+});
--- a/packages/builders/tests/interactions/SlashCommands/Options.test.ts
+++ b/packages/builders/tests/interactions/SlashCommands/Options.test.ts
@@ -0,0 +1,201 @@
+import {
+	APIApplicationCommandBooleanOption,
+	APIApplicationCommandChannelOption,
+	APIApplicationCommandIntegerOption,
+	APIApplicationCommandMentionableOption,
+	APIApplicationCommandNumberOption,
+	APIApplicationCommandRoleOption,
+	APIApplicationCommandStringOption,
+	APIApplicationCommandUserOption,
+	ApplicationCommandOptionType,
+	ChannelType,
+} from 'discord-api-types/v9';
+import {
+	SlashCommandBooleanOption,
+	SlashCommandChannelOption,
+	SlashCommandIntegerOption,
+	SlashCommandMentionableOption,
+	SlashCommandNumberOption,
+	SlashCommandRoleOption,
+	SlashCommandStringOption,
+	SlashCommandUserOption,
+} from '../../../src/index';
+
+const getBooleanOption = () =>
+	new SlashCommandBooleanOption().setName('owo').setDescription('Testing 123').setRequired(true);
+
+const getChannelOption = () =>
+	new SlashCommandChannelOption()
+		.setName('owo')
+		.setDescription('Testing 123')
+		.setRequired(true)
+		.addChannelType(ChannelType.GuildText);
+
+const getStringOption = () =>
+	new SlashCommandStringOption().setName('owo').setDescription('Testing 123').setRequired(true);
+
+const getIntegerOption = () =>
+	new SlashCommandIntegerOption()
+		.setName('owo')
+		.setDescription('Testing 123')
+		.setRequired(true)
+		.setMinValue(1)
+		.setMaxValue(10);
+
+const getNumberOption = () =>
+	new SlashCommandNumberOption()
+		.setName('owo')
+		.setDescription('Testing 123')
+		.setRequired(true)
+		.setMinValue(1)
+		.setMaxValue(10);
+
+const getUserOption = () => new SlashCommandUserOption().setName('owo').setDescription('Testing 123').setRequired(true);
+
+const getRoleOption = () => new SlashCommandRoleOption().setName('owo').setDescription('Testing 123').setRequired(true);
+
+const getMentionableOption = () =>
+	new SlashCommandMentionableOption().setName('owo').setDescription('Testing 123').setRequired(true);
+
+describe('Application Command toJSON() results', () => {
+	test('GIVEN a boolean option THEN calling toJSON should return a valid JSON', () => {
+		expect(getBooleanOption().toJSON()).toEqual<APIApplicationCommandBooleanOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Boolean,
+			required: true,
+		});
+	});
+
+	test('GIVEN a channel option THEN calling toJSON should return a valid JSON', () => {
+		expect(getChannelOption().toJSON()).toEqual<APIApplicationCommandChannelOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Channel,
+			required: true,
+			channel_types: [ChannelType.GuildText],
+		});
+	});
+
+	test('GIVEN a integer option THEN calling toJSON should return a valid JSON', () => {
+		expect(getIntegerOption().toJSON()).toEqual<APIApplicationCommandIntegerOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Integer,
+			required: true,
+			max_value: 10,
+			min_value: 1,
+		});
+
+		expect(
+			getIntegerOption().setAutocomplete(true).setChoices([]).toJSON(),
+		).toEqual<APIApplicationCommandIntegerOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Integer,
+			required: true,
+			max_value: 10,
+			min_value: 1,
+			autocomplete: true,
+			// @ts-expect-error TODO: you *can* send an empty array with autocomplete: true, should correct that in types
+			choices: [],
+		});
+
+		expect(getIntegerOption().addChoice('uwu', 1).toJSON()).toEqual<APIApplicationCommandIntegerOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Integer,
+			required: true,
+			max_value: 10,
+			min_value: 1,
+			choices: [{ name: 'uwu', value: 1 }],
+		});
+	});
+
+	test('GIVEN a mentionable option THEN calling toJSON should return a valid JSON', () => {
+		expect(getMentionableOption().toJSON()).toEqual<APIApplicationCommandMentionableOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Mentionable,
+			required: true,
+		});
+	});
+
+	test('GIVEN a number option THEN calling toJSON should return a valid JSON', () => {
+		expect(getNumberOption().toJSON()).toEqual<APIApplicationCommandNumberOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Number,
+			required: true,
+			max_value: 10,
+			min_value: 1,
+		});
+
+		expect(getNumberOption().setAutocomplete(true).setChoices([]).toJSON()).toEqual<APIApplicationCommandNumberOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Number,
+			required: true,
+			max_value: 10,
+			min_value: 1,
+			autocomplete: true,
+			// @ts-expect-error TODO: you *can* send an empty array with autocomplete: true, should correct that in types
+			choices: [],
+		});
+
+		expect(getNumberOption().addChoice('uwu', 1).toJSON()).toEqual<APIApplicationCommandNumberOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Number,
+			required: true,
+			max_value: 10,
+			min_value: 1,
+			choices: [{ name: 'uwu', value: 1 }],
+		});
+	});
+
+	test('GIVEN a role option THEN calling toJSON should return a valid JSON', () => {
+		expect(getRoleOption().toJSON()).toEqual<APIApplicationCommandRoleOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.Role,
+			required: true,
+		});
+	});
+
+	test('GIVEN a string option THEN calling toJSON should return a valid JSON', () => {
+		expect(getStringOption().toJSON()).toEqual<APIApplicationCommandStringOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.String,
+			required: true,
+		});
+
+		expect(getStringOption().setAutocomplete(true).setChoices([]).toJSON()).toEqual<APIApplicationCommandStringOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.String,
+			required: true,
+			autocomplete: true,
+			// @ts-expect-error TODO: you *can* send an empty array with autocomplete: true, should correct that in types
+			choices: [],
+		});
+
+		expect(getStringOption().addChoice('uwu', '1').toJSON()).toEqual<APIApplicationCommandStringOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.String,
+			required: true,
+			choices: [{ name: 'uwu', value: '1' }],
+		});
+	});
+
+	test('GIVEN a user option THEN calling toJSON should return a valid JSON', () => {
+		expect(getUserOption().toJSON()).toEqual<APIApplicationCommandUserOption>({
+			name: 'owo',
+			description: 'Testing 123',
+			type: ApplicationCommandOptionType.User,
+			required: true,
+		});
+	});
+});
--- a/packages/builders/tests/interactions/SlashCommands/SlashCommands.test.ts
+++ b/packages/builders/tests/interactions/SlashCommands/SlashCommands.test.ts
@@ -0,0 +1,427 @@
+import { APIApplicationCommandOptionChoice, ChannelType } from 'discord-api-types/v9';
+import {
+	SlashCommandAssertions,
+	SlashCommandBooleanOption,
+	SlashCommandBuilder,
+	SlashCommandChannelOption,
+	SlashCommandIntegerOption,
+	SlashCommandMentionableOption,
+	SlashCommandNumberOption,
+	SlashCommandRoleOption,
+	SlashCommandStringOption,
+	SlashCommandSubcommandBuilder,
+	SlashCommandSubcommandGroupBuilder,
+	SlashCommandUserOption,
+} from '../../../src/index';
+
+const largeArray = Array.from({ length: 26 }, () => 1 as unknown as APIApplicationCommandOptionChoice);
+
+const getBuilder = () => new SlashCommandBuilder();
+const getNamedBuilder = () => getBuilder().setName('example').setDescription('Example command');
+const getStringOption = () => new SlashCommandStringOption().setName('owo').setDescription('Testing 123');
+const getIntegerOption = () => new SlashCommandIntegerOption().setName('owo').setDescription('Testing 123');
+const getNumberOption = () => new SlashCommandNumberOption().setName('owo').setDescription('Testing 123');
+const getBooleanOption = () => new SlashCommandBooleanOption().setName('owo').setDescription('Testing 123');
+const getUserOption = () => new SlashCommandUserOption().setName('owo').setDescription('Testing 123');
+const getChannelOption = () => new SlashCommandChannelOption().setName('owo').setDescription('Testing 123');
+const getRoleOption = () => new SlashCommandRoleOption().setName('owo').setDescription('Testing 123');
+const getMentionableOption = () => new SlashCommandMentionableOption().setName('owo').setDescription('Testing 123');
+const getSubcommandGroup = () => new SlashCommandSubcommandGroupBuilder().setName('owo').setDescription('Testing 123');
+const getSubcommand = () => new SlashCommandSubcommandBuilder().setName('owo').setDescription('Testing 123');
+
+class Collection {
+	public get [Symbol.toStringTag]() {
+		return 'Map';
+	}
+}
+
+describe('Slash Commands', () => {
+	describe('Assertions tests', () => {
+		test('GIVEN valid name THEN does not throw error', () => {
+			expect(() => SlashCommandAssertions.validateName('ping')).not.toThrowError();
+		});
+
+		test('GIVEN invalid name THEN throw error', () => {
+			expect(() => SlashCommandAssertions.validateName(null)).toThrowError();
+
+			// Too short of a name
+			expect(() => SlashCommandAssertions.validateName('')).toThrowError();
+
+			// Invalid characters used
+			expect(() => SlashCommandAssertions.validateName('ABC123$%^&')).toThrowError();
+
+			// Too long of a name
+			expect(() =>
+				SlashCommandAssertions.validateName('qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbnm'),
+			).toThrowError();
+		});
+
+		test('GIVEN valid description THEN does not throw error', () => {
+			expect(() => SlashCommandAssertions.validateDescription('This is an OwO moment fur sure!~')).not.toThrowError();
+		});
+
+		test('GIVEN invalid description THEN throw error', () => {
+			expect(() => SlashCommandAssertions.validateDescription(null)).toThrowError();
+
+			// Too short of a description
+			expect(() => SlashCommandAssertions.validateDescription('')).toThrowError();
+
+			// Too long of a description
+			expect(() =>
+				SlashCommandAssertions.validateDescription(
+					'Lorem ipsum dolor sit amet, consectetur adipisicing elit. Magnam autem libero expedita vitae accusamus nostrum ipsam tempore repudiandae deserunt ipsum facilis, velit fugiat facere accusantium, explicabo corporis aliquam non quos.',
+				),
+			).toThrowError();
+		});
+
+		test('GIVEN valid default_permission THEN does not throw error', () => {
+			expect(() => SlashCommandAssertions.validateDefaultPermission(true)).not.toThrowError();
+		});
+
+		test('GIVEN invalid default_permission THEN throw error', () => {
+			expect(() => SlashCommandAssertions.validateDefaultPermission(null)).toThrowError();
+		});
+
+		test('GIVEN valid array of options or choices THEN does not throw error', () => {
+			expect(() => SlashCommandAssertions.validateMaxOptionsLength([])).not.toThrowError();
+
+			expect(() => SlashCommandAssertions.validateMaxChoicesLength([])).not.toThrowError();
+		});
+
+		test('GIVEN invalid options or choices THEN throw error', () => {
+			expect(() => SlashCommandAssertions.validateMaxOptionsLength(null)).toThrowError();
+
+			expect(() => SlashCommandAssertions.validateMaxChoicesLength(null)).toThrowError();
+
+			// Given an array that's too big
+			expect(() => SlashCommandAssertions.validateMaxOptionsLength(largeArray)).toThrowError();
+
+			expect(() => SlashCommandAssertions.validateMaxChoicesLength(largeArray)).toThrowError();
+		});
+
+		test('GIVEN valid required parameters THEN does not throw error', () => {
+			expect(() =>
+				SlashCommandAssertions.validateRequiredParameters(
+					'owo',
+					'My fancy command that totally exists, to test assertions',
+					[],
+				),
+			).not.toThrowError();
+		});
+	});
+
+	describe('SlashCommandBuilder', () => {
+		describe('Builder with no options', () => {
+			test('GIVEN empty builder THEN throw error when calling toJSON', () => {
+				expect(() => getBuilder().toJSON()).toThrowError();
+			});
+
+			test('GIVEN valid builder THEN does not throw error', () => {
+				expect(() => getBuilder().setName('example').setDescription('Example command').toJSON()).not.toThrowError();
+			});
+		});
+
+		describe('Builder with simple options', () => {
+			test('GIVEN valid builder with options THEN does not throw error', () => {
+				expect(() =>
+					getBuilder()
+						.setName('example')
+						.setDescription('Example command')
+						.addBooleanOption((boolean) =>
+							boolean.setName('iscool').setDescription('Are we cool or what?').setRequired(true),
+						)
+						.addChannelOption((channel) => channel.setName('iscool').setDescription('Are we cool or what?'))
+						.addMentionableOption((mentionable) => mentionable.setName('iscool').setDescription('Are we cool or what?'))
+						.addRoleOption((role) => role.setName('iscool').setDescription('Are we cool or what?'))
+						.addUserOption((user) => user.setName('iscool').setDescription('Are we cool or what?'))
+						.addIntegerOption((integer) =>
+							integer
+								.setName('iscool')
+								.setDescription('Are we cool or what?')
+								.addChoices([['Very cool', 1_000]]),
+						)
+						.addNumberOption((number) =>
+							number
+								.setName('iscool')
+								.setDescription('Are we cool or what?')
+								.addChoices([['Very cool', 1.5]]),
+						)
+						.addStringOption((string) =>
+							string
+								.setName('iscool')
+								.setDescription('Are we cool or what?')
+								.addChoices([
+									['Fancy Pants', 'fp_1'],
+									['Fancy Shoes', 'fs_1'],
+									['The Whole shebang', 'all'],
+								]),
+						)
+						.addIntegerOption((integer) =>
+							integer.setName('iscool').setDescription('Are we cool or what?').setAutocomplete(true),
+						)
+						.addNumberOption((number) =>
+							number.setName('iscool').setDescription('Are we cool or what?').setAutocomplete(true),
+						)
+						.addStringOption((string) =>
+							string.setName('iscool').setDescription('Are we cool or what?').setAutocomplete(true),
+						)
+						.toJSON(),
+				).not.toThrowError();
+			});
+
+			test('GIVEN a builder with invalid autocomplete THEN does throw an error', () => {
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addStringOption(getStringOption().setAutocomplete('not a boolean'))).toThrowError();
+			});
+
+			test('GIVEN a builder with both choices and autocomplete THEN does throw an error', () => {
+				expect(() =>
+					getBuilder().addStringOption(
+						// @ts-expect-error Checking if check works JS-side too
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+						getStringOption().setAutocomplete(true).addChoice('Fancy Pants', 'fp_1'),
+					),
+				).toThrowError();
+
+				expect(() =>
+					getBuilder().addStringOption(
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+						getStringOption()
+							.setAutocomplete(true)
+							// @ts-expect-error Checking if check works JS-side too
+							.addChoices([
+								['Fancy Pants', 'fp_1'],
+								['Fancy Shoes', 'fs_1'],
+								['The Whole shebang', 'all'],
+							]),
+					),
+				).toThrowError();
+
+				expect(() =>
+					getBuilder().addStringOption(
+						// @ts-expect-error Checking if check works JS-side too
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+						getStringOption().addChoice('Fancy Pants', 'fp_1').setAutocomplete(true),
+					),
+				).toThrowError();
+
+				expect(() => {
+					const option = getStringOption();
+					Reflect.set(option, 'autocomplete', true);
+					Reflect.set(option, 'choices', [{ name: 'Fancy Pants', value: 'fp_1' }]);
+					return option.toJSON();
+				}).toThrowError();
+
+				expect(() => {
+					const option = getNumberOption();
+					Reflect.set(option, 'autocomplete', true);
+					Reflect.set(option, 'choices', [{ name: 'Fancy Pants', value: 'fp_1' }]);
+					return option.toJSON();
+				}).toThrowError();
+
+				expect(() => {
+					const option = getIntegerOption();
+					Reflect.set(option, 'autocomplete', true);
+					Reflect.set(option, 'choices', [{ name: 'Fancy Pants', value: 'fp_1' }]);
+					return option.toJSON();
+				}).toThrowError();
+			});
+
+			test('GIVEN a builder with valid channel options and channel_types THEN does not throw an error', () => {
+				expect(() =>
+					getBuilder().addChannelOption(getChannelOption().addChannelType(ChannelType.GuildText)),
+				).not.toThrowError();
+
+				expect(() => {
+					getBuilder().addChannelOption(
+						getChannelOption().addChannelTypes([ChannelType.GuildNews, ChannelType.GuildText]),
+					);
+				}).not.toThrowError();
+			});
+
+			test('GIVEN a builder with valid channel options and channel_types THEN does throw an error', () => {
+				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelType(100))).toThrowError();
+
+				expect(() => getBuilder().addChannelOption(getChannelOption().addChannelTypes([100, 200]))).toThrowError();
+			});
+
+			test('GIVEN a builder with invalid number min/max options THEN does throw an error', () => {
+				// @ts-expect-error
+				expect(() => getBuilder().addNumberOption(getNumberOption().setMaxValue('test'))).toThrowError();
+
+				// @ts-expect-error
+				expect(() => getBuilder().addIntegerOption(getIntegerOption().setMaxValue('test'))).toThrowError();
+
+				// @ts-expect-error
+				expect(() => getBuilder().addNumberOption(getNumberOption().setMinValue('test'))).toThrowError();
+
+				// @ts-expect-error
+				expect(() => getBuilder().addIntegerOption(getIntegerOption().setMinValue('test'))).toThrowError();
+
+				expect(() => getBuilder().addIntegerOption(getIntegerOption().setMinValue(1.5))).toThrowError();
+			});
+
+			test('GIVEN a builder with valid number min/max options THEN does not throw an error', () => {
+				expect(() => getBuilder().addIntegerOption(getIntegerOption().setMinValue(1))).not.toThrowError();
+
+				expect(() => getBuilder().addNumberOption(getNumberOption().setMinValue(1.5))).not.toThrowError();
+
+				expect(() => getBuilder().addIntegerOption(getIntegerOption().setMaxValue(1))).not.toThrowError();
+
+				expect(() => getBuilder().addNumberOption(getNumberOption().setMaxValue(1.5))).not.toThrowError();
+			});
+
+			test('GIVEN an already built builder THEN does not throw an error', () => {
+				expect(() => getBuilder().addStringOption(getStringOption())).not.toThrowError();
+
+				expect(() => getBuilder().addIntegerOption(getIntegerOption())).not.toThrowError();
+
+				expect(() => getBuilder().addNumberOption(getNumberOption())).not.toThrowError();
+
+				expect(() => getBuilder().addBooleanOption(getBooleanOption())).not.toThrowError();
+
+				expect(() => getBuilder().addUserOption(getUserOption())).not.toThrowError();
+
+				expect(() => getBuilder().addChannelOption(getChannelOption())).not.toThrowError();
+
+				expect(() => getBuilder().addRoleOption(getRoleOption())).not.toThrowError();
+
+				expect(() => getBuilder().addMentionableOption(getMentionableOption())).not.toThrowError();
+			});
+
+			test('GIVEN no valid return for an addOption method THEN throw error', () => {
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addBooleanOption()).toThrowError();
+
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addBooleanOption(getRoleOption())).toThrowError();
+			});
+
+			test('GIVEN invalid name THEN throw error', () => {
+				expect(() => getBuilder().setName('TEST_COMMAND')).toThrowError();
+
+				expect(() => getBuilder().setName('ĂĂĂĂĂĂ')).toThrowError();
+			});
+
+			test('GIVEN valid names THEN does not throw error', () => {
+				expect(() => getBuilder().setName('hi_there')).not.toThrowError();
+
+				// Translation: a_command
+				expect(() => getBuilder().setName('o_comandă')).not.toThrowError();
+
+				// Translation: thx (according to GTranslate)
+				expect(() => getBuilder().setName('どうも')).not.toThrowError();
+			});
+
+			test('GIVEN invalid returns for builder THEN throw error', () => {
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addBooleanOption(true)).toThrowError();
+
+				expect(() => getBuilder().addBooleanOption(null)).toThrowError();
+
+				expect(() => getBuilder().addBooleanOption(undefined)).toThrowError();
+
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addBooleanOption(() => SlashCommandStringOption)).toThrowError();
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addBooleanOption(() => new Collection())).toThrowError();
+			});
+
+			test('GIVEN valid builder with defaultPermission false THEN does not throw error', () => {
+				expect(() => getBuilder().setName('foo').setDescription('foo').setDefaultPermission(false)).not.toThrowError();
+			});
+
+			test('GIVEN an option that is autocompletable and has choices, THEN setting choices to an empty array should not throw an error', () => {
+				expect(() =>
+					getBuilder().addStringOption(getStringOption().setAutocomplete(true).setChoices([])),
+				).not.toThrowError();
+			});
+
+			test('GIVEN an option that is autocompletable, THEN setting choices should throw an error', () => {
+				expect(() =>
+					getBuilder().addStringOption(
+						getStringOption()
+							.setAutocomplete(true)
+							.setChoices([['owo', 'uwu']]),
+					),
+				).toThrowError();
+			});
+
+			test('GIVEN an option, THEN setting choices should not throw an error', () => {
+				expect(() => getBuilder().addStringOption(getStringOption().setChoices([['owo', 'uwu']]))).not.toThrowError();
+			});
+		});
+
+		describe('Builder with subcommand (group) options', () => {
+			test('GIVEN builder with subcommand group THEN does not throw error', () => {
+				expect(() =>
+					getNamedBuilder().addSubcommandGroup((group) => group.setName('group').setDescription('Group us together!')),
+				).not.toThrowError();
+			});
+
+			test('GIVEN builder with subcommand THEN does not throw error', () => {
+				expect(() =>
+					getNamedBuilder().addSubcommand((subcommand) =>
+						subcommand.setName('boop').setDescription('Boops a fellow nerd (you)'),
+					),
+				).not.toThrowError();
+			});
+
+			test('GIVEN builder with already built subcommand group THEN does not throw error', () => {
+				expect(() => getNamedBuilder().addSubcommandGroup(getSubcommandGroup())).not.toThrowError();
+			});
+
+			test('GIVEN builder with already built subcommand THEN does not throw error', () => {
+				expect(() => getNamedBuilder().addSubcommand(getSubcommand())).not.toThrowError();
+			});
+
+			test('GIVEN builder with already built subcommand with options THEN does not throw error', () => {
+				expect(() =>
+					getNamedBuilder().addSubcommand(getSubcommand().addBooleanOption(getBooleanOption())),
+				).not.toThrowError();
+			});
+
+			test('GIVEN builder with a subcommand that tries to add an invalid result THEN throw error', () => {
+				expect(() =>
+					// @ts-expect-error Checking if check works JS-side too
+					getNamedBuilder().addSubcommand(getSubcommand()).addInteger(getInteger()),
+				).toThrowError();
+			});
+
+			test('GIVEN no valid return for an addSubcommand(Group) method THEN throw error', () => {
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addSubcommandGroup()).toThrowError();
+
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addSubcommand()).toThrowError();
+
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getBuilder().addSubcommand(getSubcommandGroup())).toThrowError();
+			});
+		});
+
+		describe('Subcommand group builder', () => {
+			test('GIVEN no valid subcommand THEN throw error', () => {
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getSubcommandGroup().addSubcommand()).toThrowError();
+
+				// @ts-expect-error Checking if not providing anything, or an invalid return type causes an error
+				expect(() => getSubcommandGroup().addSubcommand(getSubcommandGroup())).toThrowError();
+			});
+
+			test('GIVEN a valid subcommand THEN does not throw an error', () => {
+				expect(() =>
+					getSubcommandGroup()
+						.addSubcommand((sub) => sub.setName('sub').setDescription('Testing 123'))
+						.toJSON(),
+				).not.toThrowError();
+			});
+		});
+
+		describe('Subcommand builder', () => {
+			test('GIVEN a valid subcommand with options THEN does not throw error', () => {
+				expect(() => getSubcommand().addBooleanOption(getBooleanOption()).toJSON()).not.toThrowError();
+			});
+		});
+	});
+});
--- a/packages/builders/tests/messages/embed.test.ts
+++ b/packages/builders/tests/messages/embed.test.ts
@@ -0,0 +1,428 @@
+import { Embed } from '../../src';
+import type { APIEmbed } from 'discord-api-types/v9';
+
+const emptyEmbed: APIEmbed = {
+	author: undefined,
+	color: undefined,
+	description: undefined,
+	fields: [],
+	footer: undefined,
+	image: undefined,
+	provider: undefined,
+	thumbnail: undefined,
+	title: undefined,
+	url: undefined,
+	video: undefined,
+};
+
+const alpha = 'abcdefghijklmnopqrstuvwxyz';
+
+describe('Embed', () => {
+	describe('Embed getters', () => {
+		test('GIVEN an embed with specific amount of characters THEN returns amount of characters', () => {
+			const embed = new Embed({
+				title: alpha,
+				description: alpha,
+				fields: [{ name: alpha, value: alpha }],
+				author: { name: alpha },
+				footer: { text: alpha },
+			});
+
+			expect(embed.length).toBe(alpha.length * 6);
+		});
+
+		test('GIVEN an embed with zero characters THEN returns amount of characters', () => {
+			const embed = new Embed();
+
+			expect(embed.length).toBe(0);
+		});
+	});
+
+	describe('Embed title', () => {
+		test('GIVEN an embed with a pre-defined title THEN return valid toJSON data', () => {
+			const embed = new Embed({ title: 'foo' });
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, title: 'foo' });
+		});
+
+		test('GIVEN an embed using Embed#setTitle THEN return valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setTitle('foo');
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, title: 'foo' });
+		});
+
+		test('GIVEN an embed with a pre-defined title THEN unset title THEN return valid toJSON data', () => {
+			const embed = new Embed({ title: 'foo' });
+			embed.setTitle(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with an invalid title THEN throws error', () => {
+			const embed = new Embed();
+
+			expect(() => embed.setTitle('a'.repeat(257))).toThrowError();
+		});
+	});
+
+	describe('Embed description', () => {
+		test('GIVEN an embed with a pre-defined description THEN return valid toJSON data', () => {
+			const embed = new Embed({ ...emptyEmbed, description: 'foo' });
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, description: 'foo' });
+		});
+
+		test('GIVEN an embed using Embed#setDescription THEN return valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setDescription('foo');
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, description: 'foo' });
+		});
+
+		test('GIVEN an embed with a pre-defined description THEN unset description THEN return valid toJSON data', () => {
+			const embed = new Embed({ description: 'foo' });
+			embed.setDescription(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with an invalid description THEN throws error', () => {
+			const embed = new Embed();
+
+			expect(() => embed.setDescription('a'.repeat(4097))).toThrowError();
+		});
+	});
+
+	describe('Embed URL', () => {
+		test('GIVEN an embed with a pre-defined url THEN returns valid toJSON data', () => {
+			const embed = new Embed({ url: 'https://discord.js.org/' });
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				url: 'https://discord.js.org/',
+			});
+		});
+
+		test('GIVEN an embed using Embed#setURL THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setURL('https://discord.js.org/');
+
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				url: 'https://discord.js.org/',
+			});
+		});
+
+		test('GIVEN an embed with a pre-defined title THEN unset title THEN return valid toJSON data', () => {
+			const embed = new Embed({ url: 'https://discord.js.org' });
+			embed.setURL(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with an invalid URL THEN throws error', () => {
+			const embed = new Embed();
+
+			expect(() => embed.setURL('owo')).toThrowError();
+		});
+	});
+
+	describe('Embed Color', () => {
+		test('GIVEN an embed with a pre-defined color THEN returns valid toJSON data', () => {
+			const embed = new Embed({ color: 0xff0000 });
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, color: 0xff0000 });
+		});
+
+		test('GIVEN an embed using Embed#setColor THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setColor(0xff0000);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, color: 0xff0000 });
+		});
+
+		test('GIVEN an embed with a pre-defined color THEN unset color THEN return valid toJSON data', () => {
+			const embed = new Embed({ color: 0xff0000 });
+			embed.setColor(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with an invalid color THEN throws error', () => {
+			const embed = new Embed();
+
+			// @ts-expect-error
+			expect(() => embed.setColor('RED')).toThrowError();
+		});
+	});
+
+	describe('Embed Timestamp', () => {
+		const now = new Date();
+
+		test('GIVEN an embed with a pre-defined timestamp THEN returns valid toJSON data', () => {
+			const embed = new Embed({ timestamp: now.toISOString() });
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, timestamp: now.toISOString() });
+		});
+
+		test('given an embed using Embed#setTimestamp (with Date) THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setTimestamp(now);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, timestamp: now.toISOString() });
+		});
+
+		test('GIVEN an embed using Embed#setTimestamp (with int) THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setTimestamp(now.getTime());
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, timestamp: now.toISOString() });
+		});
+
+		test('GIVEN an embed using Embed#setTimestamp (default) THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setTimestamp();
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, timestamp: embed.timestamp });
+		});
+
+		test('GIVEN an embed with a pre-defined timestamp THEN unset timestamp THEN return valid toJSON data', () => {
+			const embed = new Embed({ timestamp: now.toISOString() });
+			embed.setTimestamp(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed, timestamp: undefined });
+		});
+	});
+
+	describe('Embed Thumbnail', () => {
+		test('GIVEN an embed with a pre-defined thumbnail THEN returns valid toJSON data', () => {
+			const embed = new Embed({ thumbnail: { url: 'https://discord.js.org/static/logo.svg' } });
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				thumbnail: { url: 'https://discord.js.org/static/logo.svg' },
+			});
+		});
+
+		test('GIVEN an embed using Embed#setThumbnail THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setThumbnail('https://discord.js.org/static/logo.svg');
+
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				thumbnail: { url: 'https://discord.js.org/static/logo.svg' },
+			});
+		});
+
+		test('GIVEN an embed with a pre-defined thumbnail THEN unset thumbnail THEN return valid toJSON data', () => {
+			const embed = new Embed({ thumbnail: { url: 'https://discord.js.org/static/logo.svg' } });
+			embed.setThumbnail(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with an invalid thumbnail THEN throws error', () => {
+			const embed = new Embed();
+
+			expect(() => embed.setThumbnail('owo')).toThrowError();
+		});
+	});
+
+	describe('Embed Image', () => {
+		test('GIVEN an embed with a pre-defined image THEN returns valid toJSON data', () => {
+			const embed = new Embed({ image: { url: 'https://discord.js.org/static/logo.svg' } });
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				image: { url: 'https://discord.js.org/static/logo.svg' },
+			});
+		});
+
+		test('GIVEN an embed using Embed#setImage THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setImage('https://discord.js.org/static/logo.svg');
+
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				image: { url: 'https://discord.js.org/static/logo.svg' },
+			});
+		});
+
+		test('GIVEN an embed with a pre-defined image THEN unset image THEN return valid toJSON data', () => {
+			const embed = new Embed({ image: { url: 'https://discord.js/org/static/logo.svg' } });
+			embed.setImage(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with an invalid image THEN throws error', () => {
+			const embed = new Embed();
+
+			expect(() => embed.setImage('owo')).toThrowError();
+		});
+	});
+
+	describe('Embed Author', () => {
+		test('GIVEN an embed with a pre-defined author THEN returns valid toJSON data', () => {
+			const embed = new Embed({
+				author: { name: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg', url: 'https://discord.js.org' },
+			});
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				author: { name: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg', url: 'https://discord.js.org' },
+			});
+		});
+
+		test('GIVEN an embed using Embed#setAuthor THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setAuthor({
+				name: 'Wumpus',
+				iconURL: 'https://discord.js.org/static/logo.svg',
+				url: 'https://discord.js.org',
+			});
+
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				author: { name: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg', url: 'https://discord.js.org' },
+			});
+		});
+
+		test('GIVEN an embed with a pre-defined author THEN unset author THEN return valid toJSON data', () => {
+			const embed = new Embed({
+				author: { name: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg', url: 'https://discord.js.org' },
+			});
+			embed.setAuthor(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with an invalid author name THEN throws error', () => {
+			const embed = new Embed();
+
+			expect(() => embed.setAuthor({ name: 'a'.repeat(257) })).toThrowError();
+		});
+	});
+
+	describe('Embed Footer', () => {
+		test('GIVEN an embed with a pre-defined footer THEN returns valid toJSON data', () => {
+			const embed = new Embed({
+				footer: { text: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg' },
+			});
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				footer: { text: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg' },
+			});
+		});
+
+		test('GIVEN an embed using Embed#setAuthor THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.setFooter({ text: 'Wumpus', iconURL: 'https://discord.js.org/static/logo.svg' });
+
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				footer: { text: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg' },
+			});
+		});
+
+		test('GIVEN an embed with a pre-defined footer THEN unset footer THEN return valid toJSON data', () => {
+			const embed = new Embed({ footer: { text: 'Wumpus', icon_url: 'https://discord.js.org/static/logo.svg' } });
+			embed.setFooter(null);
+
+			expect(embed.toJSON()).toStrictEqual({ ...emptyEmbed });
+		});
+
+		test('GIVEN an embed with invalid footer text THEN throws error', () => {
+			const embed = new Embed();
+
+			expect(() => embed.setFooter({ text: 'a'.repeat(2049) })).toThrowError();
+		});
+	});
+
+	describe('Embed Fields', () => {
+		test('GIVEN an embed with a pre-defined field THEN returns valid toJSON data', () => {
+			const embed = new Embed({
+				fields: [{ name: 'foo', value: 'bar', inline: undefined }],
+			});
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				fields: [{ name: 'foo', value: 'bar', inline: undefined }],
+			});
+		});
+
+		test('GIVEN an embed using Embed#addField THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.addField({ name: 'foo', value: 'bar' });
+
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				fields: [{ name: 'foo', value: 'bar', inline: undefined }],
+			});
+		});
+
+		test('GIVEN an embed using Embed#addFields THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.addFields({ name: 'foo', value: 'bar' });
+
+			expect(embed.toJSON()).toStrictEqual({
+				...emptyEmbed,
+				fields: [{ name: 'foo', value: 'bar', inline: undefined }],
+			});
+		});
+
+		test('GIVEN an embed using Embed#spliceFields THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.addFields({ name: 'foo', value: 'bar' }, { name: 'foo', value: 'baz' });
+
+			expect(embed.spliceFields(0, 1).toJSON()).toStrictEqual({
+				...emptyEmbed,
+				fields: [{ name: 'foo', value: 'baz', inline: undefined }],
+			});
+		});
+
+		test('GIVEN an embed using Embed#spliceFields THEN returns valid toJSON data', () => {
+			const embed = new Embed();
+			embed.addFields(...Array.from({ length: 23 }, () => ({ name: 'foo', value: 'bar' })));
+
+			expect(() =>
+				embed.spliceFields(0, 3, ...Array.from({ length: 5 }, () => ({ name: 'foo', value: 'bar' }))),
+			).not.toThrowError();
+		});
+
+		test('GIVEN an embed using Embed#spliceFields that adds additional fields resulting in fields > 25 THEN throws error', () => {
+			const embed = new Embed();
+			embed.addFields(...Array.from({ length: 23 }, () => ({ name: 'foo', value: 'bar' })));
+
+			expect(() =>
+				embed.spliceFields(0, 3, ...Array.from({ length: 8 }, () => ({ name: 'foo', value: 'bar' }))),
+			).toThrowError();
+		});
+
+		describe('GIVEN invalid field amount THEN throws error', () => {
+			test('', () => {
+				const embed = new Embed();
+
+				expect(() =>
+					embed.addFields(...Array.from({ length: 26 }, () => ({ name: 'foo', value: 'bar' }))),
+				).toThrowError();
+			});
+		});
+
+		describe('GIVEN invalid field name THEN throws error', () => {
+			test('', () => {
+				const embed = new Embed();
+
+				expect(() => embed.addFields({ name: '', value: 'bar' })).toThrowError();
+			});
+		});
+
+		describe('GIVEN invalid field name length THEN throws error', () => {
+			test('', () => {
+				const embed = new Embed();
+
+				expect(() => embed.addFields({ name: 'a'.repeat(257), value: 'bar' })).toThrowError();
+			});
+		});
+
+		describe('GIVEN invalid field value length THEN throws error', () => {
+			test('', () => {
+				const embed = new Embed();
+
+				expect(() => embed.addFields({ name: '', value: 'a'.repeat(1025) })).toThrowError();
+			});
+		});
+	});
+});
--- a/packages/builders/tests/messages/formatters.test.ts
+++ b/packages/builders/tests/messages/formatters.test.ts
@@ -0,0 +1,206 @@
+import {
+	blockQuote,
+	bold,
+	channelMention,
+	codeBlock,
+	Faces,
+	formatEmoji,
+	hideLinkEmbed,
+	hyperlink,
+	inlineCode,
+	italic,
+	memberNicknameMention,
+	quote,
+	roleMention,
+	spoiler,
+	strikethrough,
+	time,
+	TimestampStyles,
+	underscore,
+	userMention,
+} from '../../src';
+
+describe('Message formatters', () => {
+	describe('codeBlock', () => {
+		test('GIVEN "discord.js" with no language THEN returns "```\\ndiscord.js```"', () => {
+			expect<'```\ndiscord.js```'>(codeBlock('discord.js')).toBe('```\ndiscord.js```');
+		});
+
+		test('GIVEN "discord.js" with "js" as language THEN returns "```js\\ndiscord.js```"', () => {
+			expect<'```js\ndiscord.js```'>(codeBlock('js', 'discord.js')).toBe('```js\ndiscord.js```');
+		});
+	});
+
+	describe('inlineCode', () => {
+		test('GIVEN "discord.js" THEN returns "`discord.js`"', () => {
+			expect<'`discord.js`'>(inlineCode('discord.js')).toBe('`discord.js`');
+		});
+	});
+
+	describe('italic', () => {
+		test('GIVEN "discord.js" THEN returns "_discord.js_"', () => {
+			expect<'_discord.js_'>(italic('discord.js')).toBe('_discord.js_');
+		});
+	});
+
+	describe('bold', () => {
+		test('GIVEN "discord.js" THEN returns "**discord.js**"', () => {
+			expect<'**discord.js**'>(bold('discord.js')).toBe('**discord.js**');
+		});
+	});
+
+	describe('underscore', () => {
+		test('GIVEN "discord.js" THEN returns "__discord.js__"', () => {
+			expect<'__discord.js__'>(underscore('discord.js')).toBe('__discord.js__');
+		});
+	});
+
+	describe('strikethrough', () => {
+		test('GIVEN "discord.js" THEN returns "~~discord.js~~"', () => {
+			expect<'~~discord.js~~'>(strikethrough('discord.js')).toBe('~~discord.js~~');
+		});
+	});
+
+	describe('quote', () => {
+		test('GIVEN "discord.js" THEN returns "> discord.js"', () => {
+			expect<'> discord.js'>(quote('discord.js')).toBe('> discord.js');
+		});
+	});
+
+	describe('blockQuote', () => {
+		test('GIVEN "discord.js" THEN returns ">>> discord.js"', () => {
+			expect<'>>> discord.js'>(blockQuote('discord.js')).toBe('>>> discord.js');
+		});
+	});
+
+	describe('hideLinkEmbed', () => {
+		test('GIVEN "https://discord.js.org" THEN returns "<https://discord.js.org>"', () => {
+			expect<'<https://discord.js.org>'>(hideLinkEmbed('https://discord.js.org')).toBe('<https://discord.js.org>');
+		});
+
+		test('GIVEN new URL("https://discord.js.org") THEN returns "<https://discord.js.org>"', () => {
+			expect<`<${string}>`>(hideLinkEmbed(new URL('https://discord.js.org/'))).toBe('<https://discord.js.org/>');
+		});
+	});
+
+	describe('hyperlink', () => {
+		test('GIVEN content and string URL THEN returns "[content](url)"', () => {
+			expect<'[discord.js](https://discord.js.org)'>(hyperlink('discord.js', 'https://discord.js.org')).toBe(
+				'[discord.js](https://discord.js.org)',
+			);
+		});
+
+		test('GIVEN content and URL THEN returns "[content](url)"', () => {
+			expect<`[discord.js](${string})`>(hyperlink('discord.js', new URL('https://discord.js.org'))).toBe(
+				'[discord.js](https://discord.js.org/)',
+			);
+		});
+
+		test('GIVEN content, string URL, and title THEN returns "[content](url "title")"', () => {
+			expect<'[discord.js](https://discord.js.org "Official Documentation")'>(
+				hyperlink('discord.js', 'https://discord.js.org', 'Official Documentation'),
+			).toBe('[discord.js](https://discord.js.org "Official Documentation")');
+		});
+
+		test('GIVEN content, URL, and title THEN returns "[content](url "title")"', () => {
+			expect<`[discord.js](${string} "Official Documentation")`>(
+				hyperlink('discord.js', new URL('https://discord.js.org'), 'Official Documentation'),
+			).toBe('[discord.js](https://discord.js.org/ "Official Documentation")');
+		});
+	});
+
+	describe('spoiler', () => {
+		test('GIVEN "discord.js" THEN returns "||discord.js||"', () => {
+			expect<'||discord.js||'>(spoiler('discord.js')).toBe('||discord.js||');
+		});
+	});
+
+	describe('Mentions', () => {
+		describe('userMention', () => {
+			test('GIVEN userId THEN returns "<@[userId]>"', () => {
+				expect(userMention('139836912335716352')).toBe('<@139836912335716352>');
+			});
+		});
+
+		describe('memberNicknameMention', () => {
+			test('GIVEN memberId THEN returns "<@![memberId]>"', () => {
+				expect(memberNicknameMention('139836912335716352')).toBe('<@!139836912335716352>');
+			});
+		});
+
+		describe('channelMention', () => {
+			test('GIVEN channelId THEN returns "<#[channelId]>"', () => {
+				expect(channelMention('829924760309334087')).toBe('<#829924760309334087>');
+			});
+		});
+
+		describe('roleMention', () => {
+			test('GIVEN roleId THEN returns "<&[roleId]>"', () => {
+				expect(roleMention('815434166602170409')).toBe('<@&815434166602170409>');
+			});
+		});
+	});
+
+	describe('formatEmoji', () => {
+		test('GIVEN static emojiId THEN returns "<:_:${emojiId}>"', () => {
+			expect<`<:_:851461487498493952>`>(formatEmoji('851461487498493952')).toBe('<:_:851461487498493952>');
+		});
+
+		test('GIVEN static emojiId WITH animated explicitly false THEN returns "<:_:[emojiId]>"', () => {
+			expect<`<:_:851461487498493952>`>(formatEmoji('851461487498493952', false)).toBe('<:_:851461487498493952>');
+		});
+
+		test('GIVEN animated emojiId THEN returns "<a:_:${emojiId}>"', () => {
+			expect<`<a:_:827220205352255549>`>(formatEmoji('827220205352255549', true)).toBe('<a:_:827220205352255549>');
+		});
+	});
+
+	describe('time', () => {
+		test('GIVEN no arguments THEN returns "<t:${bigint}>"', () => {
+			jest.useFakeTimers('modern');
+			jest.setSystemTime(1566424897579);
+
+			expect<`<t:${bigint}>`>(time()).toBe('<t:1566424897>');
+
+			jest.useRealTimers();
+		});
+
+		test('GIVEN a date THEN returns "<t:${bigint}>"', () => {
+			expect<`<t:${bigint}>`>(time(new Date(1867424897579))).toBe('<t:1867424897>');
+		});
+
+		test('GIVEN a date and a style from string THEN returns "<t:${bigint}:${style}>"', () => {
+			expect<`<t:${bigint}:d>`>(time(new Date(1867424897579), 'd')).toBe('<t:1867424897:d>');
+		});
+
+		test('GIVEN a date and a format from enum THEN returns "<t:${bigint}:${style}>"', () => {
+			expect<`<t:${bigint}:R>`>(time(new Date(1867424897579), TimestampStyles.RelativeTime)).toBe('<t:1867424897:R>');
+		});
+
+		test('GIVEN a date THEN returns "<t:${time}>"', () => {
+			expect<'<t:1867424897>'>(time(1867424897)).toBe('<t:1867424897>');
+		});
+
+		test('GIVEN a date and a style from string THEN returns "<t:${time}:${style}>"', () => {
+			expect<'<t:1867424897:d>'>(time(1867424897, 'd')).toBe('<t:1867424897:d>');
+		});
+
+		test('GIVEN a date and a format from enum THEN returns "<t:${time}:${style}>"', () => {
+			expect<'<t:1867424897:R>'>(time(1867424897, TimestampStyles.RelativeTime)).toBe('<t:1867424897:R>');
+		});
+	});
+
+	describe('Faces', () => {
+		test('GIVEN Faces.Shrug THEN returns "¯\\_(ツ)\\_/¯"', () => {
+			expect<'¯\\_(ツ)\\_/¯'>(Faces.Shrug).toBe('¯\\_(ツ)\\_/¯');
+		});
+
+		test('GIVEN Faces.Tableflip THEN returns "(╯°□°）╯︵ ┻━┻"', () => {
+			expect<'(╯°□°）╯︵ ┻━┻'>(Faces.Tableflip).toBe('(╯°□°）╯︵ ┻━┻');
+		});
+
+		test('GIVEN Faces.Unflip THEN returns "┬─┬ ノ( ゜-゜ノ)"', () => {
+			expect<'┬─┬ ノ( ゜-゜ノ)'>(Faces.Unflip).toBe('┬─┬ ノ( ゜-゜ノ)');
+		});
+	});
+});