Create audits command tests
Some checks failed
continuous-integration/drone/push Build is failing

This commit is contained in:
Ethan Lane 2024-03-27 16:49:39 +00:00
parent e7fde3a2ea
commit e860a19bfe
2 changed files with 742 additions and 28 deletions

View file

@ -60,8 +60,7 @@ export default class Audits extends Command {
{ name: 'Mute', value: AuditType.Mute.toString() }, { name: 'Mute', value: AuditType.Mute.toString() },
{ name: 'Kick', value: AuditType.Kick.toString() }, { name: 'Kick', value: AuditType.Kick.toString() },
{ name: 'Ban', value: AuditType.Ban.toString() }, { name: 'Ban', value: AuditType.Ban.toString() },
) ))
.setRequired(true))
.addStringOption(option => .addStringOption(option =>
option option
.setName('reason') .setName('reason')

View file

@ -1,63 +1,778 @@
import { CommandInteraction, EmbedBuilder, PermissionsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandSubcommandBuilder, SlashCommandUserOption } from "discord.js";
import Audits from "../../src/commands/audits";
import Audit from "../../src/database/entities/Audit";
import { AuditType } from "../../src/constants/AuditType";
import AuditTools from "../../src/helpers/AuditTools";
import EmbedColours from "../../src/constants/EmbedColours";
import StringTools from "../../src/helpers/StringTools";
describe("constructor", () => { describe("constructor", () => {
test.todo("EXPECT properties to be set"); test("EXPECT properties to be set", () => {
const audits = new Audits();
expect(audits.CommandBuilder).toBeDefined();
const commandBuilder = audits.CommandBuilder as SlashCommandBuilder;
expect(commandBuilder.name).toBe("audits");
expect(commandBuilder.description).toBe("View audits of a particular user in the server");
expect(commandBuilder.default_member_permissions).toBe(PermissionsBitField.Flags.ModerateMembers.toString());
expect(commandBuilder.options.length).toBe(4);
const userSubcommand = commandBuilder.options[0] as SlashCommandSubcommandBuilder;
expect(userSubcommand.name).toBe("user");
expect(userSubcommand.description).toBe("View all audits done against a user");
expect(userSubcommand.options.length).toBe(1);
const userSubcommandUserOption = userSubcommand.options[0] as SlashCommandUserOption;
expect(userSubcommandUserOption.name).toBe("target");
expect(userSubcommandUserOption.description).toBe("The user");
expect(userSubcommandUserOption.required).toBe(true);
const viewSubcommand = commandBuilder.options[1] as SlashCommandSubcommandBuilder;
expect(viewSubcommand.name).toBe("view");
expect(viewSubcommand.description).toBe("View a particular audit");
expect(viewSubcommand.options.length).toBe(1);
const viewSubcommandAuditIdOption = viewSubcommand.options[0] as SlashCommandStringOption;
expect(viewSubcommandAuditIdOption.name).toBe("auditid");
expect(viewSubcommandAuditIdOption.description).toBe("The audit id in caps");
expect(viewSubcommandAuditIdOption.required).toBe(true);
const clearSubcommand = commandBuilder.options[2] as SlashCommandSubcommandBuilder;
expect(clearSubcommand.name).toBe("clear");
expect(clearSubcommand.description).toBe("Clears an audit from a user");
expect(clearSubcommand.options.length).toBe(1);
const clearSubcommandAuditIdOption = clearSubcommand.options[0] as SlashCommandStringOption;
expect(clearSubcommandAuditIdOption.name).toBe("auditid");
expect(clearSubcommandAuditIdOption.description).toBe("The audit id in caps");
expect(clearSubcommandAuditIdOption.required).toBe(true);
const addSubcommand = commandBuilder.options[3] as SlashCommandSubcommandBuilder;
expect(addSubcommand.name).toBe("add");
expect(addSubcommand.description).toBe("Manually add an audit");
expect(addSubcommand.options.length).toBe(3);
const addSubcommandUserOption = addSubcommand.options[0] as SlashCommandUserOption;
expect(addSubcommandUserOption.name).toBe("target");
expect(addSubcommandUserOption.description).toBe("The user");
expect(addSubcommandUserOption.required).toBe(true);
const addSubcommandTypeOption = addSubcommand.options[1] as SlashCommandStringOption;
expect(addSubcommandTypeOption.name).toBe("type");
expect(addSubcommandTypeOption.description).toBe("The type of audit");
expect(addSubcommandTypeOption.required).toBe(true);
expect(addSubcommandTypeOption.choices).toBeDefined();
expect(addSubcommandTypeOption.choices!.length).toBe(5);
const addSubcommandReasonOption = addSubcommand.options[2] as SlashCommandStringOption;
expect(addSubcommandReasonOption.name).toBe("reason");
expect(addSubcommandReasonOption.description).toBe("The reason");
});
}); });
describe('execute', () => { describe('execute', () => {
test.todo("GIVEN interaction is not a chat input command, EXPECT nothing to happen"); test("GIVEN interaction is not a chat input command, EXPECT nothing to happen", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(false),
reply: jest.fn(),
} as unknown as CommandInteraction;
test.todo("GIVEN subcommand is invalid, EXPECT error"); const audits = new Audits();
await audits.execute(interaction);
expect(interaction.isChatInputCommand).toHaveBeenCalledTimes(1);
expect(interaction.reply).not.toHaveBeenCalled();
});
test("GIVEN subcommand is invalid, EXPECT error", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("invalid"),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Subcommand doesn't exist.");
});
}); });
describe("user", () => { describe("user", () => {
test.todo("EXPECT audits for user to be sent"); test("EXPECT audits for user to be sent", async () => {
let repliedWith;
test.todo("GIVEN interaction.guildId is null, EXPECT nothing to happen"); const user = {
id: "userId",
};
const audit = {
AuditId: "auditId",
AuditType: AuditType.Warn,
WhenCreated: new Date(5 * 60 * 1000),
};
test.todo("GIVEN user is null, EXPECT error"); const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("user"),
getUser: jest.fn().mockReturnValue(user),
},
guildId: "guildId",
reply: jest.fn().mockImplementation((options) => {
repliedWith = options;
})
} as unknown as CommandInteraction;
test.todo("GIVEN audits null, EXPECT no audits to be displayed"); Audit.FetchAuditsByUserId = jest.fn().mockReturnValue([ audit ]);
AuditTools.TypeToFriendlyText = jest.fn().mockReturnValue("Warn");
test.todo("GIVEN audits length is 0, EXPECT no audits to be displayed"); const audits = new Audits();
await audits.execute(interaction);
expect(Audit.FetchAuditsByUserId).toHaveBeenCalledTimes(1);
expect(Audit.FetchAuditsByUserId).toHaveBeenCalledWith("userId", "guildId");
expect(AuditTools.TypeToFriendlyText).toHaveBeenCalledTimes(1);
expect(AuditTools.TypeToFriendlyText).toHaveBeenCalledWith(AuditType.Warn);
expect(interaction.options.getUser).toHaveBeenCalledTimes(1);
expect(interaction.options.getUser).toHaveBeenCalledWith("target");
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(repliedWith).toBeDefined();
expect(repliedWith!.embeds).toBeDefined();
expect(repliedWith!.embeds.length).toBe(1);
const embed = repliedWith!.embeds[0] as EmbedBuilder;
expect(embed.data.color).toBe(EmbedColours.Ok);
expect(embed.data.title).toBe("Audits");
expect(embed.data.description).toBe("Audits: 1");
expect(embed.data.fields).toBeDefined();
expect(embed.data.fields?.length).toBe(1);
const embedField = embed.data.fields![0];
expect(embedField.name).toBe("auditId // Warn");
expect(embedField.value).toBe(new Date(5 * 60 * 1000).toString());
});
test("GIVEN interaction.guildId is null, EXPECT nothing to happen", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("user"),
},
guildId: null,
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).not.toHaveBeenCalled();
});
test("GIVEN user is null, EXPECT error", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("user"),
getUser: jest.fn().mockReturnValue(null),
},
guildId: "guildId",
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.options.getUser).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("User not found.");
});
test("GIVEN audits null, EXPECT no audits to be displayed", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("user"),
getUser: jest.fn().mockReturnValue({}),
},
guildId: "guildId",
reply: jest.fn(),
} as unknown as CommandInteraction;
Audit.FetchAuditsByUserId = jest.fn().mockResolvedValue(null);
const audits = new Audits();
await audits.execute(interaction);
expect(Audit.FetchAuditsByUserId).toHaveBeenCalledTimes(1);
expect(interaction.options.getUser).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("There are no audits for this user.");
});
test("GIVEN audits length is 0, EXPECT no audits to be displayed", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("user"),
getUser: jest.fn().mockReturnValue({}),
},
guildId: "guildId",
reply: jest.fn(),
} as unknown as CommandInteraction;
Audit.FetchAuditsByUserId = jest.fn().mockResolvedValue([]);
const audits = new Audits();
await audits.execute(interaction);
expect(Audit.FetchAuditsByUserId).toHaveBeenCalledTimes(1);
expect(interaction.options.getUser).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("There are no audits for this user.");
});
}); });
describe("view", () => { describe("view", () => {
test.todo("EXPECT specific audit defaults to be sent"); test("EXPECT specific audit defaults to be sent", async () => {
let repliedWith;
test.todo("GIVEN interaction.guildId is null, expect nothing to happen"); const auditOption = {
value: "auditId",
};
test.todo("GIVEN auditId is null, EXPECT error"); const audit = {
Reason: "Test reason",
AuditType: AuditType.Warn,
ModeratorId: "moderatorId",
AuditId: "auditId",
};
test.todo("GIVEN auditId.value is undefined, EXPECT error"); const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("view"),
get: jest.fn().mockReturnValue(auditOption),
},
reply: jest.fn().mockImplementation((options) => {
repliedWith = options;
}),
} as unknown as CommandInteraction;
test.todo("GIVEN audit is not in database, EXPECT error"); Audit.FetchAuditByAuditId = jest.fn().mockResolvedValue(audit);
AuditTools.TypeToFriendlyText = jest.fn().mockReturnValue("Warn");
test.todo("GIVEN audit.Reason was not supplied, EXPECT reason to be defaulted"); const audits = new Audits();
await audits.execute(interaction);
expect(Audit.FetchAuditByAuditId).toHaveBeenCalledTimes(1);
expect(Audit.FetchAuditByAuditId).toHaveBeenCalledWith("AUDITID", "guildId");
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(repliedWith).toBeDefined();
expect(repliedWith!.embeds).toBeDefined();
expect(repliedWith!.embeds.length).toBe(1);
const embed = repliedWith!.embeds[0] as EmbedBuilder;
expect(embed.data.color).toBe(EmbedColours.Ok);
expect(embed.data.title).toBe("Audit");
expect(embed.data.description).toBe("AUDITID");
expect(embed.data.fields).toBeDefined();
expect(embed.data.fields!.length).toBe(3);
const embedReasonField = embed.data.fields![0];
expect(embedReasonField.name).toBe("Reason");
expect(embedReasonField.value).toBe("Test reason");
expect(embedReasonField.inline).toBe(true);
const embedTypeField = embed.data.fields![1];
expect(embedTypeField.name).toBe("Type");
expect(embedTypeField.value).toBe("Warn");
expect(embedTypeField.inline).toBe(true);
const embedModeratorField = embed.data.fields![2];
expect(embedModeratorField.name).toBe("Moderator");
expect(embedModeratorField.value).toBe("<@moderatorId>");
expect(embedModeratorField.inline).toBe(true);
});
test("GIVEN interaction.guildId is null, expect nothing to happen", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("view"),
},
guildId: null,
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).not.toHaveBeenCalled();
});
test("GIVEN auditId is null, EXPECT error", async () => {
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("view"),
get: jest.fn().mockReturnValue(null),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.options.get).toHaveBeenCalledTimes(1);
expect(interaction.options.get).toHaveBeenCalledWith("auditid");
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("AuditId not found.");
});
test("GIVEN auditId.value is undefined, EXPECT error", async () => {
const audit = {
value: undefined,
}
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("view"),
get: jest.fn().mockReturnValue(audit),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.options.get).toHaveBeenCalledTimes(1);
expect(interaction.options.get).toHaveBeenCalledWith("auditid");
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("AuditId not found.");
});
test("GIVEN audit is not in database, EXPECT error", async () => {
const audit = {
value: "auditId",
}
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("view"),
get: jest.fn().mockReturnValue(audit),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
Audit.FetchAuditByAuditId = jest.fn().mockResolvedValue(null);
const audits = new Audits();
await audits.execute(interaction);
expect(Audit.FetchAuditByAuditId).toHaveBeenCalledTimes(1);
expect(interaction.options.get).toHaveBeenCalledTimes(1);
expect(interaction.options.get).toHaveBeenCalledWith("auditid");
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Audit not found.");
});
test("GIVEN audit.Reason was not supplied, EXPECT reason to be defaulted", async () => {
let repliedWith;
const auditOption = {
value: "auditId",
};
const audit = {
Reason: undefined,
AuditType: AuditType.Warn,
ModeratorId: "moderatorId",
AuditId: "auditId",
};
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("view"),
get: jest.fn().mockReturnValue(auditOption),
},
reply: jest.fn().mockImplementation((options) => {
repliedWith = options;
}),
} as unknown as CommandInteraction;
Audit.FetchAuditByAuditId = jest.fn().mockResolvedValue(audit);
AuditTools.TypeToFriendlyText = jest.fn().mockReturnValue("Warn");
const audits = new Audits();
await audits.execute(interaction);
const embed = repliedWith!.embeds[0] as EmbedBuilder;
const embedReasonField = embed.data.fields![0];
expect(embedReasonField.name).toBe("Reason");
expect(embedReasonField.value).toBe("*none*");
expect(embedReasonField.inline).toBe(true);
});
}); });
describe("clear", () => { describe("clear", () => {
test.todo("EXPECT audit to be cleared"); test("EXPECT audit to be cleared", async () => {
const auditOption = {
value: "auditId",
}
test.todo("GIVEN interaction.guildId is null, EXPECT nothing to happen"); const audit = {};
test.todo("GIVEN auditId is null, EXPECT error"); const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("clear"),
get: jest.fn().mockReturnValue(auditOption),
},
guildId: "guildId",
reply: jest.fn(),
} as unknown as CommandInteraction;
test.todo("GIVEN auditId.value is undefined, EXPECT error"); Audit.FetchAuditByAuditId = jest.fn().mockReturnValue(audit);
Audit.Remove = jest.fn();
test.todo("GIVEN audit is not found, EXPECT error"); const audits = new Audits();
await audits.execute(interaction);
expect(Audit.FetchAuditByAuditId).toHaveBeenCalledTimes(1);
expect(Audit.FetchAuditByAuditId).toHaveBeenCalledWith("AUDITID", "guildId");
expect(Audit.Remove).toHaveBeenCalledTimes(1);
expect(interaction.options.get).toHaveBeenCalledTimes(1);
expect(interaction.options.get).toHaveBeenCalledWith("auditid");
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Audit cleared.");
});
test("GIVEN interaction.guildId is null, EXPECT nothing to happen", async () => {
const interaction = {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("clear"),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).not.toHaveBeenCalled();
});
test("GIVEN auditId is null, EXPECT error", async () => {
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("clear"),
get: jest.fn().mockReturnValue(null),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("AuditId not found.");
});
test("GIVEN auditId.value is undefined, EXPECT error", async () => {
const auditOption = {
value: undefined,
}
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("clear"),
get: jest.fn().mockReturnValue(auditOption),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("AuditId not found.");
});
test("GIVEN audit is not found, EXPECT error", async () => {
const auditOption = {
value: "auditId",
}
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("clear"),
get: jest.fn().mockReturnValue(auditOption),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
Audit.FetchAuditByAuditId = jest.fn().mockReturnValue(null);
const audits = new Audits();
await audits.execute(interaction);
expect(Audit.FetchAuditByAuditId).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Audit not found.");
});
}); });
describe("add", () => { describe("add", () => {
test.todo("EXPECT audit to be added"); test("EXPECT audit to be added", async () => {
const user = {
id: "userId",
};
test.todo("GIVEN interaction.guildId is null, EXPECT nothing to happen"); const type = {
value: AuditType.Warn,
};
test.todo("GIVEN user is null, EXPECT error"); const reason = {};
test.todo("GIVEN auditType is null, EXPECT error"); const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("add"),
getUser: jest.fn().mockReturnValue(user),
get: jest.fn().mockReturnValueOnce(type)
.mockReturnValue(reason),
},
user: {
id: "userId",
},
reply: jest.fn(),
} as unknown as CommandInteraction;
test.todo("GIVEN auditType.value is undefined, EXPECT error"); Audit.prototype.Save = jest.fn();
StringTools.RandomString = jest.fn().mockReturnValue("AUDITID");
test.todo("GIVEN reasonInput is null, EXPECT reason to be empty"); const audits = new Audits();
await audits.execute(interaction);
test.todo("GIVEN reasonType.value is undefined, EXPECT reason to be empty"); expect(Audit.prototype.Save).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Created new audit with ID `AUDITID`");
});
test("GIVEN interaction.guildId is null, EXPECT nothing to happen", async () => {
const interaction = {
guildId: null,
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("add"),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).not.toHaveBeenCalled();
});
test("GIVEN user is null, EXPECT error", async () => {
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("add"),
getUser: jest.fn().mockReturnValue(null),
get: jest.fn().mockReturnValue({}),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Invalid input.");
});
test("GIVEN auditType is null, EXPECT error", async () => {
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("add"),
getUser: jest.fn().mockReturnValue(null),
get: jest.fn().mockReturnValueOnce(null)
.mockReturnValue({}),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Invalid input.");
});
test("GIVEN auditType.value is undefined, EXPECT error", async () => {
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("add"),
getUser: jest.fn().mockReturnValue(null),
get: jest.fn().mockReturnValueOnce({
value: undefined
})
.mockReturnValue({}),
},
reply: jest.fn(),
} as unknown as CommandInteraction;
const audits = new Audits();
await audits.execute(interaction);
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Invalid input.");
});
test("GIVEN reasonInput is null, EXPECT reason to be empty", async ()=> {
let savedAudit: Audit | undefined;
const user = {
id: "userId",
};
const type = {
value: AuditType.Warn,
};
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("add"),
getUser: jest.fn().mockReturnValue(user),
get: jest.fn().mockReturnValueOnce(type)
.mockReturnValue(null),
},
user: {
id: "userId",
},
reply: jest.fn(),
} as unknown as CommandInteraction;
Audit.prototype.Save = jest.fn().mockImplementation((_, audit: Audit) => {
savedAudit = audit;
});
StringTools.RandomString = jest.fn().mockReturnValue("AUDITID");
const audits = new Audits();
await audits.execute(interaction);
expect(Audit.prototype.Save).toHaveBeenCalledTimes(1);
expect(savedAudit).toBeDefined();
expect(savedAudit!.Reason).toBe("");
});
test("GIVEN reasonType.value is undefined, EXPECT reason to be empty", async () => {
let savedAudit: Audit | undefined;
const user = {
id: "userId",
};
const type = {
value: AuditType.Warn,
};
const reason = {
value: undefined,
};
const interaction = {
guildId: "guildId",
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue("add"),
getUser: jest.fn().mockReturnValue(user),
get: jest.fn().mockReturnValueOnce(type)
.mockReturnValue(reason),
},
user: {
id: "userId",
},
reply: jest.fn(),
} as unknown as CommandInteraction;
Audit.prototype.Save = jest.fn().mockImplementation((_, audit: Audit) => {
savedAudit = audit;
});
StringTools.RandomString = jest.fn().mockReturnValue("AUDITID");
const audits = new Audits();
await audits.execute(interaction);
expect(Audit.prototype.Save).toHaveBeenCalledTimes(1);
expect(savedAudit).toBeDefined();
expect(savedAudit!.Reason).toBe("");
});
}); });