From 610086d26a51b641eea7ead9177052dfe9836416 Mon Sep 17 00:00:00 2001 From: Ethan Lane Date: Sat, 22 Jan 2022 15:12:01 +0000 Subject: [PATCH] Add unmute command tests --- src/commands/unmute.ts | 37 +- tests/commands/unmute.test.ts | 673 ++++++++++++++++++++++++++++++++++ 2 files changed, 704 insertions(+), 6 deletions(-) create mode 100644 tests/commands/unmute.test.ts diff --git a/src/commands/unmute.ts b/src/commands/unmute.ts index da870cd..51face6 100644 --- a/src/commands/unmute.ts +++ b/src/commands/unmute.ts @@ -1,5 +1,6 @@ import ErrorMessages from "../constants/ErrorMessages"; import { ICommandContext } from "../contracts/ICommandContext"; +import ICommandReturnContext from "../contracts/ICommandReturnContext"; import ErrorEmbed from "../helpers/embeds/ErrorEmbed"; import LogEmbed from "../helpers/embeds/LogEmbed"; import PublicEmbed from "../helpers/embeds/PublicEmbed"; @@ -15,13 +16,17 @@ export default class Unmute extends Command { ]; } - public override async execute(context: ICommandContext) { + public override async execute(context: ICommandContext): Promise { const targetUser = context.message.mentions.users.first(); if (!targetUser) { const embed = new ErrorEmbed(context, "User does not exist"); embed.SendToCurrentChannel(); - return; + + return { + commandContext: context, + embeds: [embed] + }; } const targetMember = context.message.guild?.member(targetUser); @@ -29,7 +34,11 @@ export default class Unmute extends Command { if (!targetMember) { const embed = new ErrorEmbed(context, "User is not in this server"); embed.SendToCurrentChannel(); - return; + + return { + commandContext: context, + embeds: [embed] + }; } const reasonArgs = context.args; @@ -38,13 +47,20 @@ export default class Unmute extends Command { const reason = reasonArgs.join(" "); if (!context.message.guild?.available) { - return; + return { + commandContext: context, + embeds: [] + }; } if (!targetMember.manageable) { const embed = new ErrorEmbed(context, ErrorMessages.InsufficientBotPermissions); embed.SendToCurrentChannel(); - return; + + return { + commandContext: context, + embeds: [embed] + }; } const logEmbed = new LogEmbed(context, "Member Unmuted"); @@ -60,12 +76,21 @@ export default class Unmute extends Command { if (!mutedRole) { const embed = new ErrorEmbed(context, ErrorMessages.RoleNotFound); embed.SendToCurrentChannel(); - return; + + return { + commandContext: context, + embeds: [embed] + }; } await targetMember.roles.remove(mutedRole, reason); logEmbed.SendToModLogsChannel(); publicEmbed.SendToCurrentChannel(); + + return { + commandContext: context, + embeds: [logEmbed, publicEmbed] + }; } } \ No newline at end of file diff --git a/tests/commands/unmute.test.ts b/tests/commands/unmute.test.ts new file mode 100644 index 0000000..1449b39 --- /dev/null +++ b/tests/commands/unmute.test.ts @@ -0,0 +1,673 @@ +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, '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`'); + + // 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'); + }); +}); \ No newline at end of file