* 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>
815 lines
24 KiB
TypeScript
815 lines
24 KiB
TypeScript
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');
|
|
});
|
|
}); |