RabbitLabs/vylbot-app
RabbitLabs/vylbot-app
5
0
Fork 0
Code Issues 86 Pull requests Projects 1 Releases 23 Packages Wiki Activity Actions

v3.0 (#145)

Browse source 
* Change rules.txt to rules.json (#31)

* Migrate to yarn

* Add role configs to config template

* Install packges and setup typescript

* Migrate entry point

* Migrate about command

* Migrate ban command

* Migrate clear command

* Migrate kick command

* Migrate mute command

* Migrate poll command

* Migrate bunny command

* Update required roles checker

* Migrate role command

* Migrate unmute command

* Migrate warn command

* Migrate eval command

* Migrate help command

* Migrate rules command

* Migrate events to typescript

* Update about command to use the PublicEmbed class

* Update ErrorMessage to ChannelNotFound

* Update messageDelete event to ignore bots

* Feature/74 merge vylbot core (#80)

* Merge VylBot-Core

* Update commands to new system

* Fix issue where events would not load

* Feature/12 create tests (#102)

* Fix tests

* Update coverage

* Remove unrequired mock files

* Add about command test

* Update about tests

* Ban command tests

* eval command tests

* Start help command tests

* Add help command tests

* Add kick command tests

* Mute command tests

* Poll command tests

* Add role command tests

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Add rules command tests

* Add unmute command tests

* Add warn command tests

* Add MemberEvents tests

* Add GuildMemberUpdate tests

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Add MessageEvents tests

* Add StringTools test

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Add embed tests

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Add GitHub Actions

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Move to tslint

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Remove tslint

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Remove linting script

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Update rules with blog website and event spoilers rule" (#106)

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Containerise bot (#107)

* Add moderator names to audit reason (#108)

* Feature/48 database (#114)

* Add database and default values

* Add ability to save a setting to the database

* Get commands and events to use database

* Setup and config command

* Update commands to check roles per server

* Different rules per server

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Different prefix per server

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Add verification system

Signed-off-by: Ethan Lane <ethan@vylpes.com>

* Disabled commands per server

* Add devmode for default prefix

* Update embeds

* Fix broken tests

* Feature/66 add different commands per server (#122)

* Add ability for server exclusive commands

* Add MankBot server-exclusive commands

* Add lobby entity to database

* Add documentation

* Add setup command for lobby (#123)

* Update bot to discord.js v13 (#125)

* Update bot to discord.js v13

* Remove debug code

* 110 commandshelp about command errors which causes command to not run (#126)

* Change onMessage to onMessageCreate

* Fix help command

* Add override for bot owner and server owner (#135)

* Change help command so exclusive commands can only be seen for the server they're assigned to (#136)

* Change parsing to not crash if invalid (#142)

* 137 role command cannot read properties of undefined (#141)

* Fix issue with bot crashing

* Fix server prefix not showing

* Add easy way to configure role command

* Move help text to its own directory

* Make role config command to use role id

* Get lobby command to use IDs instead of names (#144)

Co-authored-by: Vylpes <getgravitysoftware@gmail.com>
This commit is contained in:
Vylpes 2022-04-24 14:46:37 +01:00 • committed by GitHub
parent 1168898e57
commit 04a4a6204c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
118 changed files with 13966 additions and 4027 deletions
Download patch file Download diff file Expand all files Collapse all files

152
tests/commands/about.test.ts Normal file
View file

@ -0,0 +1,152 @@
import { Message } from "discord.js";
import { mock } from "jest-mock-extended";
import About from "../../src/commands/about";
import { ICommandContext } from "../../src/contracts/ICommandContext";
import PublicEmbed from "../../src/helpers/embeds/PublicEmbed";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect values set', () => {
const about = new About();
expect(about._category).toBe("General");
});
});
describe('Execute', () => {
test('Expect embed to be made and sent to the current channel', async () => {
process.env = {
BOT_VER: "BOT_VER",
BOT_AUTHOR: "BOT_AUTHOR",
BOT_DATE: "BOT_DATE"
};
const message = mock<Message>();
message.channel.send = jest.fn();
const context: ICommandContext = {
name: "about",
args: [],
message: message
};
const about = new About();
const result = await about.execute(context);
expect(message.channel.send).toBeCalledTimes(1);
});
test('Expect embed send to have values', async () => {
process.env = {
BOT_VER: "BOT_VER",
BOT_AUTHOR: "BOT_AUTHOR",
BOT_DATE: "BOT_DATE"
};
const message = mock<Message>();
message.channel.send = jest.fn();
const context: ICommandContext = {
name: "about",
args: [],
message: message
};
const about = new About();
const result = await about.execute(context);
expect(result.embeds.length).toBe(1);
const embed = result.embeds[0];
expect(embed.title).toBe('About');
expect(embed.description).toBe('');
expect(embed.fields.length).toBe(3);
});
test('Expect version field to have values', async () => {
process.env = {
BOT_VER: "BOT_VER",
BOT_AUTHOR: "BOT_AUTHOR",
BOT_DATE: "BOT_DATE"
};
const message = mock<Message>();
message.channel.send = jest.fn();
const context: ICommandContext = {
name: "about",
args: [],
message: message
};
const about = new About();
const result = await about.execute(context);
const embed = result.embeds[0];
const field = embed.fields[0];
expect(field.name).toBe('Version');
expect(field.value).toBe('BOT_VER');
});
test('Expect author field to have values', async () => {
process.env = {
BOT_VER: "BOT_VER",
BOT_AUTHOR: "BOT_AUTHOR",
BOT_DATE: "BOT_DATE"
};
const message = mock<Message>();
message.channel.send = jest.fn();
const context: ICommandContext = {
name: "about",
args: [],
message: message
};
const about = new About();
const result = await about.execute(context);
const embed = result.embeds[0];
const field = embed.fields[1];
expect(field.name).toBe('Author');
expect(field.value).toBe('BOT_AUTHOR');
});
test('Expect version field to have values', async () => {
process.env = {
BOT_VER: "BOT_VER",
BOT_AUTHOR: "BOT_AUTHOR",
BOT_DATE: "BOT_DATE"
};
const message = mock<Message>();
message.channel.send = jest.fn();
const context: ICommandContext = {
name: "about",
args: [],
message: message
};
const about = new About();
const result = await about.execute(context);
const embed = result.embeds[0];
const field = embed.fields[2];
expect(field.name).toBe('Date');
expect(field.value).toBe('BOT_DATE');
});
});

724
tests/commands/ban.test.ts Normal file
View file

@ -0,0 +1,724 @@
import { GuildMember, Message, TextChannel, User } from "discord.js";
import Ban from "../../src/commands/ban";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect values to be set', () => {
process.env.ROLES_MODERATOR = 'Moderator';
const ban = new Ban();
expect(ban._category).toBe('Moderation');
expect(ban._roles.length).toBe(1);
expect(ban._roles[0]).toBe('Moderator');
});
});
describe('Execute', () => {
test('Given user has permission, expect user to be banned', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban', 'Test', 'Reason'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).toBeCalledTimes(1);
expect(mentionedMember.ban).toBeCalledWith({ reason: 'Moderator: AUTHORTAG, Reason: Test Reason' });
});
test('Given moderator did not supply a reason, expect default message', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).toBeCalledTimes(1);
expect(mentionedMember.ban).toBeCalledWith({ reason: 'Moderator: AUTHORTAG, Reason: *none*' });
});
test('Given user has permissions, expect embeds to be correct', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban', 'Test', 'Reason'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
expect(result.embeds.length).toBe(2);
const logEmbed = result.embeds[0];
const publicEmbed = result.embeds[1];
expect(logEmbed.title).toBe('Member Banned');
expect(publicEmbed.title).toBe("");
expect(publicEmbed.description).toBe('[object Object] has been banned');
expect(logEmbed.fields.length).toBe(3);
expect(publicEmbed.fields.length).toBe(0);
});
test('Given user has permission, expect logEmbed fields to be correct', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn().mockReturnValue('URL'),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban', 'Test', 'Reason'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
const logEmbed = result.embeds[0];
const fieldUser = logEmbed.fields[0];
const fieldModerator = logEmbed.fields[1];
const fieldReason = logEmbed.fields[2];
expect(fieldUser.name).toBe("User");
expect(fieldUser.value).toBe("[object Object] `USERTAG`");
expect(logEmbed.thumbnail?.url).toBe("URL");
expect(fieldModerator.name).toBe('Moderator');
expect(fieldModerator.value).toBe('[object Object] `AUTHORTAG`');
expect(fieldReason.name).toBe('Reason');
expect(fieldReason.value).toBe('Test Reason');
});
test('Given moderator did not supply a reason, expect reason field to be default message', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn().mockReturnValue('URL'),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
const logEmbed = result.embeds[0];
const fieldUser = logEmbed.fields[0];
const fieldModerator = logEmbed.fields[1];
const fieldReason = logEmbed.fields[2];
expect(fieldUser.name).toBe("User");
expect(fieldUser.value).toBe("[object Object] `USERTAG`");
expect(logEmbed.thumbnail?.url).toBe("URL");
expect(fieldModerator.name).toBe('Moderator');
expect(fieldModerator.value).toBe('[object Object] `AUTHORTAG`');
expect(fieldReason.name).toBe('Reason');
expect(fieldReason.value).toBe('*none*');
});
test('Given user is not mentioned, expect error embed to be sent', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(null);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban', 'Test', 'Reason'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(mentionedMember.ban).not.toBeCalled();
expect(result.embeds.length).toBe(1);
const embedError = result.embeds[0];
expect(embedError.description).toBe('User does not exist');
});
test('Given member is not in server, expect error embed to be sent', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(null);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban', 'Test', 'Reason'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(mentionedMember.ban).not.toBeCalled();
expect(result.embeds.length).toBe(1);
const embedError = result.embeds[0];
expect(embedError.description).toBe('User is not in this server');
});
test('Given guild is unavailable, expect return and do nothing', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: true,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: false
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban', 'Test', 'Reason'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
expect(messageChannelSend).not.toBeCalled();
expect(logChannel.send).not.toBeCalled();
expect(mentionedMember.ban).not.toBeCalled();
expect(result.embeds.length).toBe(0);
});
test('Given bot cant ban user, expect error embed to be sent', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
bannable: false,
ban: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'ban',
args: ['ban', 'Test', 'Reason'],
message: message
};
const ban = new Ban();
const result = await ban.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(mentionedMember.ban).not.toBeCalled();
expect(result.embeds.length).toBe(1);
const embedError = result.embeds[0];
expect(embedError.description).toBe('Unable to do this action, am I missing permissions?');
});
});

178
tests/commands/clear.test.ts Normal file
View file

@ -0,0 +1,178 @@
import { Message } from "discord.js";
import Clear from "../../src/commands/clear";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect values to be set', () => {
process.env = {
ROLES_MODERATOR: "Moderator"
};
const clear = new Clear();
expect(clear._category).toBe('Moderation');
expect(clear._roles.length).toBe(1);
expect(clear._roles[0]).toBe('Moderator');
});
});
describe('Execute', () => {
test('Given valid arguments, expect messages to be cleared', async () => {
const messageChannelSend = jest.fn();
const messageChannelBulkDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend,
bulkDelete: messageChannelBulkDelete
}
} as unknown as Message;
const context: ICommandContext = {
name: 'clear',
args: ['5'],
message: message
};
const clear = new Clear();
const result = await clear.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageChannelBulkDelete).toBeCalledWith(5);
expect(result.embeds.length).toBe(1);
// PublicEmbed
const publicEmbed = result.embeds[0];
expect(publicEmbed.title).toBe('');
expect(publicEmbed.description).toBe('5 message(s) were removed');
});
test('Given argument is not given, expect error embed to be sent', async () => {
const messageChannelSend = jest.fn();
const messageChannelBulkDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend,
bulkDelete: messageChannelBulkDelete
}
} as unknown as Message;
const context: ICommandContext = {
name: 'clear',
args: [],
message: message
};
const clear = new Clear();
const result = await clear.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageChannelBulkDelete).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// ErrorEmbed
const errorEmbed = result.embeds[0];
expect(errorEmbed.title).toBeNull();
expect(errorEmbed.description).toBe('Please specify an amount between 1 and 100');
});
test('Given argument is not a number, expect error embed to be sent', async () => {
const messageChannelSend = jest.fn();
const messageChannelBulkDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend,
bulkDelete: messageChannelBulkDelete
}
} as unknown as Message;
const context: ICommandContext = {
name: 'clear',
args: ['A'],
message: message
};
const clear = new Clear();
const result = await clear.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageChannelBulkDelete).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// ErrorEmbed
const errorEmbed = result.embeds[0];
expect(errorEmbed.title).toBeNull();
expect(errorEmbed.description).toBe('Please specify an amount between 1 and 100');
});
test('Given argument is less than 1, expect error embed to be sent', async () => {
const messageChannelSend = jest.fn();
const messageChannelBulkDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend,
bulkDelete: messageChannelBulkDelete
}
} as unknown as Message;
const context: ICommandContext = {
name: 'clear',
args: ['0'],
message: message
};
const clear = new Clear();
const result = await clear.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageChannelBulkDelete).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// ErrorEmbed
const errorEmbed = result.embeds[0];
expect(errorEmbed.title).toBeNull();
expect(errorEmbed.description).toBe('Please specify an amount between 1 and 100');
});
test('Given argument is more than 100, expect error embed to be sent', async () => {
const messageChannelSend = jest.fn();
const messageChannelBulkDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend,
bulkDelete: messageChannelBulkDelete
}
} as unknown as Message;
const context: ICommandContext = {
name: 'clear',
args: ['101'],
message: message
};
const clear = new Clear();
const result = await clear.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageChannelBulkDelete).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// ErrorEmbed
const errorEmbed = result.embeds[0];
expect(errorEmbed.title).toBeNull();
expect(errorEmbed.description).toBe('Please specify an amount between 1 and 100');
});
});

136
tests/commands/eval.test.ts Normal file
View file

@ -0,0 +1,136 @@
import { Message } from "discord.js";
import Evaluate from "../../src/commands/eval";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect values to be set', () => {
const evaluate = new Evaluate();
expect(evaluate._category).toBe('Owner');
});
});
describe('Execute', () => {
test('Given user has permission, expect eval statement ran', () => {
process.env = {
BOT_OWNERID: 'OWNERID'
};
console.log = jest.fn();
global.eval = jest.fn()
.mockReturnValue('General Kenobi');
const messageChannelSend = jest.fn();
const message = {
author: {
id: 'OWNERID'
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'eval',
args: ['echo', 'Hello', 'there'],
message: message
};
const evaluate = new Evaluate();
const result = evaluate.execute(context);
expect(console.log).toBeCalledWith('Eval Statement: echo Hello there');
expect(global.eval).toBeCalledWith('echo Hello there');
expect(result.embeds.length).toBe(1);
// PublicEmbed
const publicEmbed = result.embeds[0];
expect(publicEmbed.title).toBe('');
expect(publicEmbed.description).toBe('General Kenobi');
});
test('Given user does not have permission, expect nothing to occur', () => {
process.env = {
BOT_OWNERID: 'DIFFERENT'
};
console.log = jest.fn();
global.eval = jest.fn()
.mockReturnValue('General Kenobi');
const messageChannelSend = jest.fn();
const message = {
author: {
id: 'OWNERID'
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'eval',
args: ['echo', 'Hello', 'there'],
message: message
};
const evaluate = new Evaluate();
const result = evaluate.execute(context);
expect(console.log).not.toBeCalled();
expect(global.eval).not.toBeCalled();
expect(result.embeds.length).toBe(0);
});
test('Given eval failed, expect error embed to be sent', () => {
process.env = {
BOT_OWNERID: 'OWNERID'
};
console.log = jest.fn();
global.eval = jest.fn()
.mockImplementation(() => {
throw new Error('Error message');
});
const messageChannelSend = jest.fn();
const message = {
author: {
id: 'OWNERID'
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'eval',
args: ['echo', 'Hello', 'there'],
message: message
};
const evaluate = new Evaluate();
const result = evaluate.execute(context);
expect(console.log).toBeCalledWith('Eval Statement: echo Hello there');
expect(global.eval).toBeCalledWith('echo Hello there');
expect(result.embeds.length).toBe(1);
// ErrorEmbed
const errorEmbed = result.embeds[0];
expect(errorEmbed.title).toBeNull();
expect(errorEmbed.description).toBe('Error: Error message');
});
});

267
tests/commands/help.test.ts Normal file
View file

@ -0,0 +1,267 @@
import Help, { ICommandData } from "../../src/commands/help";
import { Message } from "discord.js";
import { ICommandContext } from "../../src/contracts/ICommandContext";
const oldCwd = process.cwd();
describe('Constructor', () => {
test('Expect properties to be set', () => {
const help = new Help();
expect(help._category).toBe('General');
});
});
describe('Execute', () => {
test('Given no arguments were given, expect SendAll to be executed', () => {
const message = {} as unknown as Message;
const context: ICommandContext = {
name: 'help',
args: [],
message: message
};
const help = new Help();
help.SendAll = jest.fn();
help.SendSingle = jest.fn();
help.execute(context);
expect(help.SendAll).toBeCalled();
expect(help.SendSingle).not.toBeCalled();
});
test('Given an argument was given, expect SendSingle to be executed', () => {
const message = {} as unknown as Message;
const context: ICommandContext = {
name: 'help',
args: ['about'],
message: message
};
const help = new Help();
help.SendAll = jest.fn();
help.SendSingle = jest.fn();
help.execute(context);
expect(help.SendAll).not.toBeCalled();
expect(help.SendSingle).toBeCalled();
});
});
describe('SendAll', () => {
test('Expect embed with all commands to be sent', () => {
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'help',
args: [],
message: message
};
const help = new Help();
const commandData0: ICommandData = {
Exists: true,
Name: 'about',
Category: 'general',
Roles: []
};
const commandData1: ICommandData = {
Exists: true,
Name: 'role',
Category: 'general',
Roles: []
};
help.GetAllCommandData = jest.fn()
.mockReturnValue([commandData0, commandData1]);
const result = help.SendAll(context);
expect(help.GetAllCommandData).toBeCalled();
expect(messageChannelSend).toBeCalled();
expect(result.embeds.length).toBe(1);
// PublicEmbed
const publicEmbed = result.embeds[0];
expect(publicEmbed.fields.length).toBe(1);
// PublicEmbed -> GeneralCategory Field
const publicEmbedFieldGeneral = publicEmbed.fields[0];
expect(publicEmbedFieldGeneral.name).toBe('General');
expect(publicEmbedFieldGeneral.value).toBe('about, role');
});
});
describe('SendSingle', () => {
test('Given command exists, expect embed to be sent with command fields', () => {
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'help',
args: ['about'],
message: message
};
const commandData: ICommandData = {
Exists: true,
Name: 'about',
Category: 'general',
Roles: ['role1', 'role2']
};
const help = new Help();
help.GetCommandData = jest.fn()
.mockReturnValue(commandData);
const result = help.SendSingle(context);
expect(help.GetCommandData).toBeCalledWith('about');
expect(messageChannelSend).toBeCalled();
expect(result.embeds.length).toBe(1);
// PublicEmbed
const publicEmbed = result.embeds[0];
expect(publicEmbed.title).toBe('About');
expect(publicEmbed.description).toBe('');
expect(publicEmbed.fields.length).toBe(2);
// PublicEmbed -> Category Field
const fieldCategory = publicEmbed.fields[0];
expect(fieldCategory.name).toBe('Category');
expect(fieldCategory.value).toBe('General');
// PublicEmbed -> RequiredRoles Field
const fieldRoles = publicEmbed.fields[1];
expect(fieldRoles.name).toBe('Required Roles');
expect(fieldRoles.value).toBe('Role1, Role2');
});
test('Given command does not exist, expect error embed to be sent', () => {
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'help',
args: ['about'],
message: message
};
const commandData: ICommandData = {
Exists: false
};
const help = new Help();
help.GetCommandData = jest.fn()
.mockReturnValue(commandData);
const result = help.SendSingle(context);
expect(help.GetCommandData).toBeCalledWith('about');
expect(messageChannelSend).toBeCalled();
expect(result.embeds.length).toBe(1);
// ErrorEmbed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Command does not exist');
});
});
describe('GetAllCommandData', () => {
test('Expect array of command data to be returned', () => {
process.env = {
FOLDERS_COMMANDS: "commands"
};
process.cwd = jest.fn()
.mockReturnValue(`${oldCwd}/tests/_mocks`);
const help = new Help();
const result = help.GetAllCommandData();
expect(result.length).toBe(1);
// Mock Command
const mockCommand = result[0];
expect(mockCommand.Exists).toBeTruthy();
expect(mockCommand.Name).toBe("mockCmd");
expect(mockCommand.Category).toBe("General");
expect(mockCommand.Roles!.length).toBe(1);
expect(mockCommand.Roles![0]).toBe("Moderator");
});
});
describe('GetCommandData', () => {
test('Given command exists, expect data to be returned', () => {
process.env = {
FOLDERS_COMMANDS: "commands"
};
process.cwd = jest.fn()
.mockReturnValue(`${oldCwd}/tests/_mocks`);
const help = new Help();
const result = help.GetCommandData('mockCmd');
expect(result.Exists).toBeTruthy();
expect(result.Name).toBe("mockCmd");
expect(result.Category).toBe("General");
expect(result.Roles!.length).toBe(1);
expect(result.Roles![0]).toBe("Moderator");
});
test('Given command does not exist, expect exists false to be returned', () => {
process.env = {
FOLDERS_COMMANDS: "commands"
};
const oldCwd = process.cwd();
process.cwd = jest.fn()
.mockReturnValue(`${oldCwd}/tests/_mocks`);
const help = new Help();
const result = help.GetCommandData('none');
expect(result.Exists).toBeFalsy();
});
});

549
tests/commands/kick.test.ts Normal file
View file

@ -0,0 +1,549 @@
import { mock } from "jest-mock-extended";
import { GuildMember, Message, TextChannel, User } from "discord.js";
import Kick from "../../src/commands/kick";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect properties to be set', () => {
process.env = {
ROLES_MODERATOR: "Moderator"
};
const kick = new Kick();
expect(kick._category).toBe('Moderation');
expect(kick._roles.length).toBe(1);
expect(kick._roles[0]).toBe('Moderator');
});
});
describe('Execute', () => {
test('Given user has permission, expect user to be kicked', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const member = {
kickable: true,
kick: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: "kick",
args: ["USER", "Test", "Reason"],
message: message
}
const kick = new Kick();
const result = await kick.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).toBeCalledTimes(1);
expect(member.kick).toBeCalledWith('Moderator: AUTHORTAG, Reason: Test Reason');
expect(result.embeds.length).toBe(2);
// Log Embed
const logEmbed = result.embeds[0];
expect(logEmbed.title).toBe('Member Kicked');
expect(logEmbed.fields.length).toBe(3);
// Log Embed -> User Field
const logEmbedFieldUser = logEmbed.fields[0];
expect(logEmbedFieldUser.name).toBe('User');
expect(logEmbedFieldUser.value).toBe('[object Object] `USERTAG`');
expect(logEmbedFieldUser.inline).toBeTruthy();
// Log Embed -> Moderator Field
const logEmbedFieldModerator = logEmbed.fields[1];
expect(logEmbedFieldModerator.name).toBe('Moderator');
expect(logEmbedFieldModerator.value).toBe('[object Object] `AUTHORTAG`');
// Log Embed -> Reason Field
const logEmbedFieldReason = logEmbed.fields[2];
expect(logEmbedFieldReason.name).toBe('Reason');
expect(logEmbedFieldReason.value).toBe('Test Reason');
});
test('Given moderator did not supply a reason, expect default reason to be added', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const member = {
kickable: true,
kick: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: "kick",
args: ["USER"],
message: message
}
const kick = new Kick();
const result = await kick.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).toBeCalledTimes(1);
expect(member.kick).toBeCalledWith('Moderator: AUTHORTAG, Reason: *none*');
expect(result.embeds.length).toBe(2);
// Log Embed
const logEmbed = result.embeds[0];
expect(logEmbed.title).toBe('Member Kicked');
expect(logEmbed.fields.length).toBe(3);
// Log Embed -> User Field
const logEmbedFieldUser = logEmbed.fields[0];
expect(logEmbedFieldUser.name).toBe('User');
expect(logEmbedFieldUser.value).toBe('[object Object] `USERTAG`');
expect(logEmbedFieldUser.inline).toBeTruthy();
// Log Embed -> Moderator Field
const logEmbedFieldModerator = logEmbed.fields[1];
expect(logEmbedFieldModerator.name).toBe('Moderator');
expect(logEmbedFieldModerator.value).toBe('[object Object] `AUTHORTAG`');
// Log Embed -> Reason Field
const logEmbedFieldReason = logEmbed.fields[2];
expect(logEmbedFieldReason.name).toBe('Reason');
expect(logEmbedFieldReason.value).toBe('*none*');
});
test('Given target user is not found, expect user does not exist error', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs'
}
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const member = {
kickable: true,
kick: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(null);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: "kick",
args: ["USER", "Test", "Reason"],
message: message
}
const kick = new Kick();
const result = await kick.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(member.kick).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe(null);
expect(embed.description).toBe('User does not exist');
});
test('Given target member is not found, expect user is not in this server error', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs'
}
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const member = {
kickable: true,
kick: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(null);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: "kick",
args: ["USER", "Test", "Reason"],
message: message
}
const kick = new Kick();
const result = await kick.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(member.kick).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe(null);
expect(embed.description).toBe('User is not in this server');
});
test('Given guild is not available, expect to stop', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs'
}
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const member = {
kickable: true,
kick: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: false
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: "kick",
args: ["USER", "Test", "Reason"],
message: message
}
const kick = new Kick();
const result = await kick.execute(context);
expect(messageChannelSend).not.toBeCalled();
expect(logChannel.send).not.toBeCalled();
expect(member.kick).not.toBeCalled();
expect(result.embeds.length).toBe(0);
});
test('Given client can not kick member, expect error', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs'
}
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const member = {
kickable: false,
kick: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: "kick",
args: ["USER", "Test", "Reason"],
message: message
}
const kick = new Kick();
const result = await kick.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(member.kick).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe(null);
expect(embed.description).toBe('Unable to do this action, am I missing permissions?');
});
});

815
tests/commands/mute.test.ts Normal file
View file

@ -0,0 +1,815 @@
import { mock } from "jest-mock-extended";
import { GuildMember, Message, Role, TextChannel, User } from "discord.js";
import Mute from "../../src/commands/mute";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect properties to be set', () => {
process.env = {
ROLES_MODERATOR: 'Moderator'
};
const mute = new Mute();
expect(mute._category).toBe("Moderation");
expect(mute._roles.length).toBe(1);
expect(mute._roles[0]).toBe('Moderator');
});
});
describe('Execute', () => {
test('Given user has permission, expect user to be given muted role', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
add: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Mute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildChannelsCacheFind).toBeCalledTimes(1);
expect(messageChannelSend).toBeCalledTimes(1);
expect(member.roles.add).toBeCalledWith(role, 'Moderator: AUTHORTAG, Reason: Test Reason');
expect(result.embeds.length).toBe(2);
// Log Embed
const logEmbed = result.embeds[0];
expect(logEmbed.title).toBe('Member Muted');
expect(logEmbed.fields.length).toBe(3);
// Log Embed -> User Field
const logEmbedUserField = logEmbed.fields[0];
expect(logEmbedUserField.name).toBe('User');
expect(logEmbedUserField.value).toBe('[object Object] `USERTAG`');
expect(logEmbedUserField.inline).toBeTruthy();
// Log Embed -> Moderator Field
const logEmbedModeratorField = logEmbed.fields[1];
expect(logEmbedModeratorField.name).toBe('Moderator');
expect(logEmbedModeratorField.value).toBe('[object Object] `AUTHORTAG`');
// Log Embed -> Reason Field
const logEmbedFieldReason = logEmbed.fields[2];
expect(logEmbedFieldReason.name).toBe('Reason');
expect(logEmbedFieldReason.value).toBe('Test Reason');
// Public Embed
const publicEmbed = result.embeds[1];
expect(publicEmbed.title).toBe('');
expect(publicEmbed.description).toBe('[object Object] has been muted');
});
test('Given moderator did not supply a reason, expect default reason used', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
add: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER'],
message: message
};
const mute = new Mute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildChannelsCacheFind).toBeCalledTimes(1);
expect(messageChannelSend).toBeCalledTimes(1);
expect(member.roles.add).toBeCalledWith(role, 'Moderator: AUTHORTAG, Reason: *none*');
expect(result.embeds.length).toBe(2);
// Log Embed
const logEmbed = result.embeds[0];
expect(logEmbed.title).toBe('Member Muted');
expect(logEmbed.fields.length).toBe(3);
// Log Embed -> User Field
const logEmbedUserField = logEmbed.fields[0];
expect(logEmbedUserField.name).toBe('User');
expect(logEmbedUserField.value).toBe('[object Object] `USERTAG`');
expect(logEmbedUserField.inline).toBeTruthy();
// Log Embed -> Moderator Field
const logEmbedModeratorField = logEmbed.fields[1];
expect(logEmbedModeratorField.name).toBe('Moderator');
expect(logEmbedModeratorField.value).toBe('[object Object] `AUTHORTAG`');
// Log Embed -> Reason Field
const logEmbedFieldReason = logEmbed.fields[2];
expect(logEmbedFieldReason.name).toBe('Reason');
expect(logEmbedFieldReason.value).toBe('*none*');
// Public Embed
const publicEmbed = result.embeds[1];
expect(publicEmbed.title).toBe('');
expect(publicEmbed.description).toBe('[object Object] has been muted');
});
test('Given user did not mention a user, expect user not to exist', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
add: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(null);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Mute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).not.toBeCalled();
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('User does not exist');
});
test('Given member can not be found from user, expect user to not be in server', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
add: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(null);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Mute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('User is not in this server');
});
test('Given guild is unavailable, expect execution to stop', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
add: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: false,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Mute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).not.toBeCalled();
expect(result.embeds.length).toBe(0);
});
test('Given client can not manage user, expect insufficient permissions', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: false,
roles: {
add: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Mute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Unable to do this action, am I missing permissions?');
});
test('Given muted role can not be found, expect role not found', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
add: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockReturnValue(undefined);
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Mute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Unable to find role');
});
});

262
tests/commands/poll.test.ts Normal file
View file

@ -0,0 +1,262 @@
import { Message, MessageEmbed } from "discord.js";
import Poll from "../../src/commands/poll";
import { ICommandContext } from "../../src/contracts/ICommandContext";
describe('Constructor', () => {
test('Expect properties to be set', () => {
const poll = new Poll();
expect(poll._category).toBe('General');
});
});
describe('Execute', () => {
test('Given input is valid, expect poll to be generated', async () => {
const returnMessageReact = jest.fn();
const returnMessage = {
react: returnMessageReact
} as unknown as Message;
const messageChannelSend = jest.fn()
.mockReturnValue(returnMessage);
const messageDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
delete: messageDelete,
deletable: true
} as unknown as Message;
const context: ICommandContext = {
name: 'poll',
args: ['Test', 'title;', 'one;', 'two'],
message: message
};
const poll = new Poll();
const result = await poll.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageDelete).toBeCalledTimes(1);
expect(returnMessageReact).toBeCalledTimes(2);
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe('Test title');
expect(embed.description).toBe(':one: one\n:two: two');
});
test('Given message is not deletable by client, expect it not to attempt deletion', async () => {
const returnMessageReact = jest.fn();
const returnMessage = {
react: returnMessageReact
} as unknown as Message;
const messageChannelSend = jest.fn()
.mockReturnValue(returnMessage);
const messageDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
delete: messageDelete,
deletable: false
} as unknown as Message;
const context: ICommandContext = {
name: 'poll',
args: ['Test', 'title;', 'one;', 'two'],
message: message
};
const poll = new Poll();
const result = await poll.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageDelete).not.toBeCalled();
expect(returnMessageReact).toBeCalledTimes(2);
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe('Test title');
expect(embed.description).toBe(':one: one\n:two: two');
});
test('Given no arguments, expect error embed', async () => {
const returnMessageReact = jest.fn();
const returnMessage = {
react: returnMessageReact
} as unknown as Message;
const messageChannelSend = jest.fn()
.mockReturnValue(returnMessage);
const messageDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
delete: messageDelete,
deletable: true
} as unknown as Message;
const context: ICommandContext = {
name: 'poll',
args: [],
message: message
};
const poll = new Poll();
const result = await poll.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageDelete).not.toBeCalled();
expect(returnMessageReact).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Usage: <title>;<option 1>;<option 2>... (separate options with semicolons), maximum of 9 options');
});
test('Given only 1 option, expect error embed', async () => {
const returnMessageReact = jest.fn();
const returnMessage = {
react: returnMessageReact
} as unknown as Message;
const messageChannelSend = jest.fn()
.mockReturnValue(returnMessage);
const messageDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
delete: messageDelete,
deletable: true
} as unknown as Message;
const context: ICommandContext = {
name: 'poll',
args: ['Test', 'title;', 'one'],
message: message
};
const poll = new Poll();
const result = await poll.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageDelete).not.toBeCalled();
expect(returnMessageReact).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Usage: <title>;<option 1>;<option 2>... (separate options with semicolons), maximum of 9 options');
});
test('Given 9 options, expect poll to be generated', async () => {
const returnMessageReact = jest.fn();
const returnMessage = {
react: returnMessageReact
} as unknown as Message;
const messageChannelSend = jest.fn()
.mockReturnValue(returnMessage);
const messageDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
delete: messageDelete,
deletable: true
} as unknown as Message;
const context: ICommandContext = {
name: 'poll',
args: ['Test', 'title;', 'one;', 'two;', 'three;', 'four;', 'five;', 'six;', 'seven;', 'eight;', 'nine'],
message: message
};
const poll = new Poll();
const result = await poll.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageDelete).toBeCalledTimes(1);
expect(returnMessageReact).toBeCalledTimes(9);
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe('Test title');
expect(embed.description).toBe(':one: one\n:two: two\n:three: three\n:four: four\n:five: five\n:six: six\n:seven: seven\n:eight: eight\n:nine: nine');
});
test('Given 10 options, expect error embed', async () => {
const returnMessageReact = jest.fn();
const returnMessage = {
react: returnMessageReact
} as unknown as Message;
const messageChannelSend = jest.fn()
.mockReturnValue(returnMessage);
const messageDelete = jest.fn();
const message = {
channel: {
send: messageChannelSend
},
delete: messageDelete,
deletable: true
} as unknown as Message;
const context: ICommandContext = {
name: 'poll',
args: ['Test', 'title;', 'one;', 'two;', 'three;', 'four;', 'five;', 'six;', 'seven;', 'eight;', 'nine;', 'ten'],
message: message
};
const poll = new Poll();
const result = await poll.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(messageDelete).not.toBeCalled();
expect(returnMessageReact).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Usage: <title>;<option 1>;<option 2>... (separate options with semicolons), maximum of 9 options');
});
});

411
tests/commands/role.test.ts Normal file
View file

@ -0,0 +1,411 @@
import { GuildMemberRoleManager, Message, Role as DiscordRole } from "discord.js";
import { mock } from "jest-mock-extended";
import Role from "../../src/commands/role";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect properties are set', () => {
const role = new Role();
expect(role._category).toBe("General");
});
});
describe('Execute', () => {
test('Given no arguments were given, expect SendRolesList to be executed', async () => {
process.env = {
COMMANDS_ROLE_ROLES: 'One,Two'
};
const message = {} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: [],
message: message
};
const role = new Role();
role.SendRolesList = jest.fn();
role.ToggleRole = jest.fn();
await role.execute(context);
expect(role.SendRolesList).toBeCalledWith(context, ['One', 'Two']);
expect(role.ToggleRole).not.toBeCalled();
});
test('Given an argument was given, expect ToggleRole to be executed', async () => {
process.env = {
COMMANDS_ROLE_ROLES: 'One,Two'
};
const message = {} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: ['One'],
message: message
};
const role = new Role();
role.SendRolesList = jest.fn();
role.ToggleRole = jest.fn();
await role.execute(context);
expect(role.SendRolesList).not.toBeCalled();
expect(role.ToggleRole).toBeCalledWith(context, ['One', 'Two']);
});
});
describe('SendRolesList', () => {
test('Expect embed with roles to be sent to the current channel', () => {
process.env = {
BOT_PREFIX: '!'
};
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: [],
message: message
};
const roles = ['One', 'Two'];
const role = new Role();
const result = role.SendRolesList(context, roles);
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe('Roles');
expect(embed.description).toBe('Do !role <role> to get the role!\nOne\nTwo');
});
});
describe('ToggleRole', () => {
test('Given role name is a valid role AND user does not have the role, expect role to be added', async () => {
const discordRole = {} as unknown as DiscordRole;
const messageMemberRolesCacheFind = jest.fn()
.mockReturnValue(undefined);
const messageGuildRolesCacheFind = jest.fn()
.mockReturnValue(discordRole);
const messageChannelSend = jest.fn();
const message = {
member: {
roles: {
cache: {
find: messageMemberRolesCacheFind
}
}
},
guild: {
roles: {
cache: {
find: messageGuildRolesCacheFind
}
}
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: ['One'],
message: message
};
const roles = ['One', 'Two'];
const role = new Role();
role.AddRole = jest.fn();
role.RemoveRole = jest.fn();
const result = await role.ToggleRole(context, roles);
expect(messageMemberRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageChannelSend).not.toBeCalled();
expect(role.AddRole).toBeCalledWith(context, discordRole);
expect(role.RemoveRole).not.toBeCalled();
expect(result.embeds.length).toBe(0);
});
test('Given role name is a valid role AND user has the role, expect role to be removed', async () => {
const discordRole = {} as unknown as DiscordRole;
const messageMemberRolesCacheFind = jest.fn()
.mockReturnValue(discordRole);
const messageGuildRolesCacheFind = jest.fn()
.mockReturnValue(discordRole);
const messageChannelSend = jest.fn();
const message = {
member: {
roles: {
cache: {
find: messageMemberRolesCacheFind
}
}
},
guild: {
roles: {
cache: {
find: messageGuildRolesCacheFind
}
}
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: ['One'],
message: message
};
const roles = ['One', 'Two'];
const role = new Role();
role.AddRole = jest.fn();
role.RemoveRole = jest.fn();
const result = await role.ToggleRole(context, roles);
expect(messageMemberRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageChannelSend).not.toBeCalled();
expect(role.AddRole).not.toBeCalled();
expect(role.RemoveRole).toBeCalledWith(context, discordRole);
expect(result.embeds.length).toBe(0);
});
test('Given role requested is not in the roles array, expect role not assignable error', async () => {
const discordRole = {} as unknown as DiscordRole;
const messageMemberRolesCacheFind = jest.fn()
.mockReturnValue(undefined);
const messageGuildRolesCacheFind = jest.fn()
.mockReturnValue(discordRole);
const messageChannelSend = jest.fn();
const message = {
member: {
roles: {
cache: {
find: messageMemberRolesCacheFind
}
}
},
guild: {
roles: {
cache: {
find: messageGuildRolesCacheFind
}
}
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: ['Three'],
message: message
};
const roles = ['One', 'Two'];
const role = new Role();
role.AddRole = jest.fn();
role.RemoveRole = jest.fn();
const result = await role.ToggleRole(context, roles);
expect(messageMemberRolesCacheFind).not.toBeCalled();
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(role.AddRole).not.toBeCalled();
expect(role.RemoveRole).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe("This role isn't marked as assignable, to see a list of assignable roles, run this command without any parameters");
});
test('Given the role is not in the guild, expect error', async () => {
const discordRole = {} as unknown as DiscordRole;
const messageMemberRolesCacheFind = jest.fn()
.mockReturnValue(undefined);
const messageGuildRolesCacheFind = jest.fn()
.mockReturnValue(undefined);
const messageChannelSend = jest.fn();
const message = {
member: {
roles: {
cache: {
find: messageMemberRolesCacheFind
}
}
},
guild: {
roles: {
cache: {
find: messageGuildRolesCacheFind
}
}
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: ['One'],
message: message
};
const roles = ['One', 'Two'];
const role = new Role();
role.AddRole = jest.fn();
role.RemoveRole = jest.fn();
const result = await role.ToggleRole(context, roles);
expect(messageMemberRolesCacheFind).not.toBeCalled();
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageChannelSend).toBeCalledTimes(1);
expect(role.AddRole).not.toBeCalled();
expect(role.RemoveRole).not.toBeCalled();
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe("The current server doesn't have this role. Please contact the server's moderators");
});
});
describe('AddRole', () => {
test('Expect role to be added to user', async () => {
const messageChannelSend = jest.fn();
const guildMemberRoleManager = mock<GuildMemberRoleManager>();
const message = {
member: {
roles: guildMemberRoleManager
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: ['One'],
message: message
};
const discordRole = {
name: 'One'
} as unknown as DiscordRole;
const role = new Role();
const result = await role.AddRole(context, discordRole);
expect(guildMemberRoleManager.add).toBeCalledWith(discordRole, "Toggled with role command");
expect(messageChannelSend).toBeCalled();
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe('');
expect(embed.description).toBe('Gave role: One');
});
});
describe('RemoveRole', () => {
test('Expect role to be removed from user', async () => {
const messageChannelSend = jest.fn();
const guildMemberRoleManager = mock<GuildMemberRoleManager>();
const message = {
member: {
roles: guildMemberRoleManager
},
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'role',
args: ['One'],
message: message
};
const discordRole = {
name: 'One'
} as unknown as DiscordRole;
const role = new Role();
const result = await role.RemoveRole(context, discordRole);
expect(guildMemberRoleManager.remove).toBeCalledWith(discordRole, "Toggled with role command");
expect(messageChannelSend).toBeCalled();
expect(result.embeds.length).toBe(1);
// Embed
const embed = result.embeds[0];
expect(embed.title).toBe('');
expect(embed.description).toBe('Removed role: One');
});
});

106
tests/commands/rules.test.ts Normal file
View file

@ -0,0 +1,106 @@
import { Message } from "discord.js";
import Rules from "../../src/commands/rules";
import { ICommandContext } from "../../src/contracts/ICommandContext";
const oldCwd = process.cwd();
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect properties to be set', () => {
process.env = {
ROLES_MODERATOR: "Moderator"
};
const rules = new Rules();
expect(rules._category).toBe("Admin");
expect(rules._roles.length).toBe(1);
expect(rules._roles[0]).toBe("Moderator");
});
});
describe('Execute', () => {
test('Given rules exist, expect rules to be sent to current channel', () => {
process.env = {
COMMANDS_RULES_FILE: 'rules/rules.json'
};
process.cwd = jest.fn()
.mockReturnValue(`${oldCwd}/tests/_mocks`);
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'rules',
args: [],
message: message
};
const rules = new Rules();
const result = rules.execute(context);
expect(messageChannelSend).toBeCalledTimes(2);
expect(result.embeds.length).toBe(2);
// Header Embed
const embedHeader = result.embeds[0];
expect(embedHeader.title).toBe("");
expect(embedHeader.description).toBe("");
expect(embedHeader.image?.url).toBe("IMAGEURL");
expect(embedHeader.footer?.text).toBe("");
// Main Embed
const embedMain = result.embeds[1];
expect(embedMain.title).toBe("TITLE 1");
expect(embedMain.description).toBe("DESCRIPTION 1A\nDESCRIPTION 1B");
expect(embedMain.image?.url).toBe("");
expect(embedMain.footer?.text).toBe("FOOTER 1");
});
test('Given rules file does not exist, expect does not exist error', () => {
process.env = {
COMMANDS_RULES_FILE: 'rules/none.json'
};
process.cwd = jest.fn()
.mockReturnValue(`${oldCwd}/tests/_mocks`);
const messageChannelSend = jest.fn();
const message = {
channel: {
send: messageChannelSend
}
} as unknown as Message;
const context: ICommandContext = {
name: 'rules',
args: [],
message: message
};
const rules = new Rules();
const result = rules.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe("Rules file doesn't exist");
});
});

813
tests/commands/unmute.test.ts Normal file
View file

@ -0,0 +1,813 @@
import { GuildMember, Message, Role, TextChannel, User } from "discord.js";
import Unmute from "../../src/commands/unmute";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect properties to be set', () => {
process.env = {
ROLES_MODERATOR: 'Moderator'
};
const mute = new Unmute();
expect(mute._category).toBe("Moderation");
expect(mute._roles.length).toBe(1);
expect(mute._roles[0]).toBe('Moderator');
});
});
describe('Execute', () => {
test('Given user has permission, expect user to be given muted role', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
remove: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Unmute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildChannelsCacheFind).toBeCalledTimes(1);
expect(messageChannelSend).toBeCalledTimes(1);
expect(member.roles.remove).toBeCalledWith(role, 'Moderator: AUTHORTAG, Reason: Test Reason');
expect(result.embeds.length).toBe(2);
// Log Embed
const logEmbed = result.embeds[0];
expect(logEmbed.title).toBe('Member Unmuted');
expect(logEmbed.fields.length).toBe(3);
// Log Embed -> User Field
const logEmbedUserField = logEmbed.fields[0];
expect(logEmbedUserField.name).toBe('User');
expect(logEmbedUserField.value).toBe('[object Object] `USERTAG`');
expect(logEmbedUserField.inline).toBeTruthy();
// Log Embed -> Moderator Field
const logEmbedModeratorField = logEmbed.fields[1];
expect(logEmbedModeratorField.name).toBe('Moderator');
expect(logEmbedModeratorField.value).toBe('[object Object] `AUTHORTAG`');
// Log Embed -> Reason Field
const logEmbedFieldReason = logEmbed.fields[2];
expect(logEmbedFieldReason.name).toBe('Reason');
expect(logEmbedFieldReason.value).toBe('Test Reason');
// Public Embed
const publicEmbed = result.embeds[1];
expect(publicEmbed.title).toBe('');
expect(publicEmbed.description).toBe('[object Object] has been unmuted');
});
test('Given moderator did not supply a reason, expect default reason is used', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
remove: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER'],
message: message
};
const mute = new Unmute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildChannelsCacheFind).toBeCalledTimes(1);
expect(messageChannelSend).toBeCalledTimes(1);
expect(member.roles.remove).toBeCalledWith(role, 'Moderator: AUTHORTAG, Reason: *none*');
expect(result.embeds.length).toBe(2);
// Log Embed
const logEmbed = result.embeds[0];
expect(logEmbed.title).toBe('Member Unmuted');
expect(logEmbed.fields.length).toBe(3);
// Log Embed -> User Field
const logEmbedUserField = logEmbed.fields[0];
expect(logEmbedUserField.name).toBe('User');
expect(logEmbedUserField.value).toBe('[object Object] `USERTAG`');
expect(logEmbedUserField.inline).toBeTruthy();
// Log Embed -> Moderator Field
const logEmbedModeratorField = logEmbed.fields[1];
expect(logEmbedModeratorField.name).toBe('Moderator');
expect(logEmbedModeratorField.value).toBe('[object Object] `AUTHORTAG`');
// Log Embed -> Reason Field
const logEmbedFieldReason = logEmbed.fields[2];
expect(logEmbedFieldReason.name).toBe('Reason');
expect(logEmbedFieldReason.value).toBe('*none*');
// Public Embed
const publicEmbed = result.embeds[1];
expect(publicEmbed.title).toBe('');
expect(publicEmbed.description).toBe('[object Object] has been unmuted');
});
test('Given user did not mention a user, expect user not to exist', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
remove: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(null);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Unmute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).not.toBeCalled();
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('User does not exist');
});
test('Given member can not be found from user, expect user to not be in server', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
remove: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(null);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Unmute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('User is not in this server');
});
test('Given guild is unavailable, expect execution to stop', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
remove: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: false,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Unmute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).not.toBeCalled();
expect(result.embeds.length).toBe(0);
});
test('Given client can not manage user, expect insufficient permissions', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: false,
roles: {
remove: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockImplementation((callback): Role | undefined => {
const result = callback(role);
if (!result) {
return undefined;
}
return role;
});
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Unmute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).not.toBeCalled();
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Unable to do this action, am I missing permissions?');
});
test('Given muted role can not be found, expect role not found', async () => {
process.env = {
CHANNELS_LOGS_MOD: 'mod-logs',
ROLES_MUTED: 'Muted'
};
const user = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const messageAuthor = {
tag: 'AUTHORTAG'
} as unknown as User;
const member = {
manageable: true,
roles: {
remove: jest.fn()
}
} as unknown as GuildMember;
const role = {
name: 'Muted'
} as unknown as Role;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(user);
const messageGuildMember = jest.fn()
.mockReturnValue(member);
const messageGuildRolesCacheFind = jest.fn()
.mockReturnValue(undefined);
const messageChannelSend = jest.fn();
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember,
available: true,
roles: {
cache: {
find: messageGuildRolesCacheFind
}
},
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
}
},
channel: {
send: messageChannelSend
},
author: messageAuthor
} as unknown as Message;
const context: ICommandContext = {
name: 'mute',
args: ['USER', 'Test', 'Reason'],
message: message
};
const mute = new Unmute();
const result = await mute.execute(context);
expect(messageMentionsUsersFirst).toBeCalledTimes(1);
expect(messageGuildMember).toBeCalledWith(user);
expect(messageGuildRolesCacheFind).toBeCalledTimes(1);
expect(messageGuildChannelsCacheFind).not.toBeCalled();
expect(messageChannelSend).toBeCalledTimes(1);
expect(result.embeds.length).toBe(1);
// Error Embed
const errorEmbed = result.embeds[0];
expect(errorEmbed.description).toBe('Unable to find role');
});
});

485
tests/commands/warn.test.ts Normal file
View file

@ -0,0 +1,485 @@
import { GuildMember, Message, TextChannel, User } from "discord.js";
import Warn from "../../src/commands/warn";
import { ICommandContext } from "../../src/contracts/ICommandContext";
beforeEach(() => {
process.env = {};
});
describe('Constructor', () => {
test('Expect values to be set', () => {
process.env.ROLES_MODERATOR = 'Moderator';
const warn = new Warn();
expect(warn._category).toBe('Moderation');
expect(warn._roles.length).toBe(1);
expect(warn._roles[0]).toBe('Moderator');
});
});
describe('Execute', () => {
test('Given user has permission, expect user to be warnned', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
warnnable: true,
warn: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'warn',
args: ['warn', 'Test', 'Reason'],
message: message
};
const warn = new Warn();
const result = await warn.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).toBeCalledTimes(1);
});
test('Given user has permissions, expect embeds to be correct', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
warnnable: true,
warn: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'warn',
args: ['warn', 'Test', 'Reason'],
message: message
};
const warn = new Warn();
const result = await warn.execute(context);
expect(result.embeds.length).toBe(2);
const logEmbed = result.embeds[0];
const publicEmbed = result.embeds[1];
expect(logEmbed.title).toBe('Member Warned');
expect(publicEmbed.title).toBe("");
expect(publicEmbed.description).toBe('[object Object] has been warned');
expect(logEmbed.fields.length).toBe(3);
expect(publicEmbed.fields.length).toBe(1);
expect(publicEmbed.fields[0].name).toBe('Reason');
expect(publicEmbed.fields[0].value).toBe('Test Reason');
});
test('Given user has permission, expect logEmbed fields to be correct', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn().mockReturnValue('URL'),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
warnnable: true,
warn: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'warn',
args: ['warn', 'Test', 'Reason'],
message: message
};
const warn = new Warn();
const result = await warn.execute(context);
const logEmbed = result.embeds[0];
const fieldUser = logEmbed.fields[0];
const fieldModerator = logEmbed.fields[1];
const fieldReason = logEmbed.fields[2];
expect(fieldUser.name).toBe("User");
expect(fieldUser.value).toBe("[object Object] `USERTAG`");
expect(logEmbed.thumbnail?.url).toBe("URL");
expect(fieldModerator.name).toBe('Moderator');
expect(fieldModerator.value).toBe('[object Object] `AUTHORTAG`');
expect(fieldReason.name).toBe('Reason');
expect(fieldReason.value).toBe('Test Reason');
});
test('Given user is not mentioned, expect error embed to be sent', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedMember = {
warnnable: true,
warn: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(null);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'warn',
args: ['warn', 'Test', 'Reason'],
message: message
};
const warn = new Warn();
const result = await warn.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(result.embeds.length).toBe(1);
const embedError = result.embeds[0];
expect(embedError.description).toBe('User does not exist');
});
test('Given member is not in server, expect error embed to be sent', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
warnnable: true,
warn: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(null);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: true
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'warn',
args: ['warn', 'Test', 'Reason'],
message: message
};
const warn = new Warn();
const result = await warn.execute(context);
expect(messageChannelSend).toBeCalledTimes(1);
expect(logChannel.send).not.toBeCalled();
expect(result.embeds.length).toBe(1);
const embedError = result.embeds[0];
expect(embedError.description).toBe('User is not in this server');
});
test('Given guild is unavailable, expect return and do nothing', async () => {
process.env = {
ROLES_MODERATOR: 'Moderator',
CHANNELS_LOGS_MOD: 'mod-logs'
};
const mentionedUser = {
displayAvatarURL: jest.fn(),
tag: 'USERTAG'
} as unknown as User;
const mentionedMember = {
warnnable: true,
warn: jest.fn()
} as unknown as GuildMember;
const logChannel = {
name: 'mod-logs',
send: jest.fn()
} as unknown as TextChannel;
const messageChannelSend = jest.fn();
const messageMentionsUsersFirst = jest.fn()
.mockReturnValue(mentionedUser);
const messageGuildMember = jest.fn()
.mockReturnValue(mentionedMember);
const messageGuildChannelsCacheFind = jest.fn()
.mockImplementation((callback): TextChannel | undefined => {
const result = callback(logChannel);
if (!result) {
return undefined;
}
return logChannel;
});
const message = {
channel: {
send: messageChannelSend
},
mentions: {
users: {
first: messageMentionsUsersFirst
}
},
guild: {
member: messageGuildMember ,
channels: {
cache: {
find: messageGuildChannelsCacheFind
}
},
available: false
},
author: {
tag: 'AUTHORTAG'
}
} as unknown as Message;
const context: ICommandContext = {
name: 'warn',
args: ['warn', 'Test', 'Reason'],
message: message
};
const warn = new Warn();
const result = await warn.execute(context);
expect(messageChannelSend).not.toBeCalled();
expect(logChannel.send).not.toBeCalled();
expect(result.embeds.length).toBe(0);
});
});