Command to allow the user to buy more effects (#424)
All checks were successful
Deploy To Stage / build (push) Successful in 54s
Deploy To Stage / deploy (push) Successful in 16s

# Description

- Create a command to generate an embed for the user to be able to buy more effects
- This embed will contain the details about the effect as well as 2 buttons; Confirm and Cancel
- The confirm button will call the button event to:
    - Remove the currency from the user
    - Give the user the effect to their inventory
- The cancel button will just disable the buttons, so the user can't accidentally use it if they don't want to.

#381

## Type of change

Please delete options that are not relevant.

- [x] New feature (non-breaking change which adds functionality)

# How Has This Been Tested?

- Have created unit tests and tested locally

# Checklist

- [ ] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my own code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings
- [ ] I have added tests that provde my fix is effective or that my feature works
- [ ] New and existing unit tests pass locally with my changes
- [ ] Any dependent changes have been merged and published in downstream modules

Reviewed-on: #424
Reviewed-by: VylpesTester <tester@vylpes.com>
Co-authored-by: Ethan Lane <ethan@vylpes.com>
Co-committed-by: Ethan Lane <ethan@vylpes.com>
This commit is contained in:
Ethan Lane 2025-03-26 18:30:16 +00:00 committed by Vylpes
parent c6b458199c
commit 5089ad6ab6
20 changed files with 942 additions and 97 deletions

View file

@ -3,6 +3,7 @@ import { ButtonEvent } from "../type/buttonEvent";
import List from "./Effects/List";
import Use from "./Effects/Use";
import AppLogger from "../client/appLogger";
import Buy from "./Effects/Buy";
export default class Effects extends ButtonEvent {
public override async execute(interaction: ButtonInteraction) {
@ -15,6 +16,9 @@ export default class Effects extends ButtonEvent {
case "use":
await Use.Execute(interaction);
break;
case "buy":
await Buy.Execute(interaction);
break;
default:
AppLogger.LogError("Buttons/Effects", `Unknown action, ${action}`);
}

View file

@ -0,0 +1,120 @@
import {ButtonInteraction} from "discord.js";
import AppLogger from "../../client/appLogger";
import EffectHelper from "../../helpers/EffectHelper";
import EmbedColours from "../../constants/EmbedColours";
import User from "../../database/entities/app/User";
import {EffectDetails} from "../../constants/EffectDetails";
export default class Buy {
public static async Execute(interaction: ButtonInteraction) {
const subaction = interaction.customId.split(" ")[2];
switch (subaction) {
case "confirm":
await this.Confirm(interaction);
break;
case "cancel":
await this.Cancel(interaction);
break;
default:
AppLogger.LogError("Buy", `Unknown subaction, effects ${subaction}`);
}
}
private static async Confirm(interaction: ButtonInteraction) {
const id = interaction.customId.split(" ")[3];
const quantity = interaction.customId.split(" ")[4];
if (!id || !quantity) {
AppLogger.LogError("Buy Confirm", "Not enough parameters");
return;
}
const effectDetail = EffectDetails.get(id);
if (!effectDetail) {
AppLogger.LogError("Buy Confirm", "Effect detail not found!");
return;
}
const quantityNumber = Number(quantity);
if (!quantityNumber || quantityNumber < 1) {
AppLogger.LogError("Buy Confirm", "Invalid number");
return;
}
const totalCost = effectDetail.cost * quantityNumber;
const user = await User.FetchOneById(User, interaction.user.id);
if (!user) {
AppLogger.LogError("Buy Confirm", "Unable to find user");
return;
}
if (user.Currency < totalCost) {
interaction.reply(`You don't have enough currency to buy this! You have \`${user.Currency} Currency\` and need \`${totalCost} Currency\`!`);
return;
}
user.RemoveCurrency(totalCost);
await user.Save(User, user);
await EffectHelper.AddEffectToUserInventory(interaction.user.id, id, quantityNumber);
const generatedEmbed = await EffectHelper.GenerateEffectBuyEmbed(interaction.user.id, id, quantityNumber, true);
if (typeof generatedEmbed == "string") {
await interaction.reply(generatedEmbed);
return;
}
generatedEmbed.embed.setColor(EmbedColours.Success);
generatedEmbed.embed.setFooter({ text: "Purchased" });
await interaction.update({
embeds: [ generatedEmbed.embed ],
components: [ generatedEmbed.row ],
});
}
private static async Cancel(interaction: ButtonInteraction) {
const id = interaction.customId.split(" ")[3];
const quantity = interaction.customId.split(" ")[4];
if (!id || !quantity) {
AppLogger.LogError("Buy Cancel", "Not enough parameters");
return;
}
const effectDetail = EffectDetails.get(id);
if (!effectDetail) {
AppLogger.LogError("Buy Cancel", "Effect detail not found!");
return;
}
const quantityNumber = Number(quantity);
if (!quantityNumber || quantityNumber < 1) {
AppLogger.LogError("Buy Cancel", "Invalid number");
return;
}
const generatedEmbed = await EffectHelper.GenerateEffectBuyEmbed(interaction.user.id, id, quantityNumber, true);
if (typeof generatedEmbed == "string") {
await interaction.reply(generatedEmbed);
return;
}
generatedEmbed.embed.setColor(EmbedColours.Error);
generatedEmbed.embed.setFooter({ text: "Cancelled" });
await interaction.update({
embeds: [ generatedEmbed.embed ],
components: [ generatedEmbed.row ],
});
}
}

View file

@ -11,7 +11,7 @@ export default async function List(interaction: ButtonInteraction) {
return;
}
const result = await EffectHelper.GenerateEffectEmbed(interaction.user.id, page);
const result = await EffectHelper.GenerateEffectListEmbed(interaction.user.id, page);
await interaction.update({
embeds: [ result.embed ],

View file

@ -1,10 +1,10 @@
import { ActionRowBuilder, ButtonBuilder, ButtonStyle, CommandInteraction, EmbedBuilder, SlashCommandBuilder } from "discord.js";
import { CommandInteraction, SlashCommandBuilder } from "discord.js";
import { Command } from "../type/command";
import EffectHelper from "../helpers/EffectHelper";
import { EffectDetails } from "../constants/EffectDetails";
import TimeLengthInput from "../helpers/TimeLengthInput";
import EmbedColours from "../constants/EmbedColours";
import { EffectChoices } from "../constants/EffectDetails";
import AppLogger from "../client/appLogger";
import List from "./effects/List";
import Use from "./effects/Use";
import Buy from "./effects/Buy";
export default class Effects extends Command {
constructor() {
@ -27,9 +27,19 @@ export default class Effects extends Command {
.setName("id")
.setDescription("The effect id to use")
.setRequired(true)
.setChoices([
{ name: "Unclaimed Chance Up", value: "unclaimed" },
])));
.setChoices(EffectChoices)))
.addSubcommand(x => x
.setName("buy")
.setDescription("Buy more effects")
.addStringOption(y => y
.setName("id")
.setDescription("The effect id to buy")
.setRequired(true)
.setChoices(EffectChoices))
.addNumberOption(y => y
.setName("quantity")
.setDescription("The amount to buy")
.setMinValue(1)));
}
public override async execute(interaction: CommandInteraction) {
@ -39,80 +49,16 @@ export default class Effects extends Command {
switch (subcommand) {
case "list":
await this.List(interaction);
await List(interaction);
break;
case "use":
await this.Use(interaction);
await Use(interaction);
break;
case "buy":
await Buy(interaction);
break;
default:
AppLogger.LogError("Commands/Effects", `Invalid subcommand: ${subcommand}`);
}
}
private async List(interaction: CommandInteraction) {
const pageOption = interaction.options.get("page");
const page = !isNaN(Number(pageOption?.value)) ? Number(pageOption?.value) : 1;
const result = await EffectHelper.GenerateEffectEmbed(interaction.user.id, page);
await interaction.reply({
embeds: [ result.embed ],
components: [ result.row ],
});
}
private async Use(interaction: CommandInteraction) {
const id = interaction.options.get("id", true).value!.toString();
const effectDetail = EffectDetails.get(id);
if (!effectDetail) {
AppLogger.LogWarn("Commands/Effects", `Unable to find effect details for ${id}`);
await interaction.reply("Unable to find effect!");
return;
}
const canUseEffect = await EffectHelper.CanUseEffect(interaction.user.id, id);
if (!canUseEffect) {
await interaction.reply("Unable to use effect! Please make sure you have it in your inventory and is not on cooldown");
return;
}
const timeLengthInput = TimeLengthInput.ConvertFromMilliseconds(effectDetail.duration);
const embed = new EmbedBuilder()
.setTitle("Effect Confirmation")
.setDescription("Would you like to use this effect?")
.setColor(EmbedColours.Ok)
.addFields([
{
name: "Effect",
value: effectDetail.friendlyName,
inline: true,
},
{
name: "Length",
value: timeLengthInput.GetLengthShort(),
inline: true,
},
]);
const row = new ActionRowBuilder<ButtonBuilder>()
.addComponents([
new ButtonBuilder()
.setLabel("Confirm")
.setCustomId(`effects use confirm ${effectDetail.id}`)
.setStyle(ButtonStyle.Primary),
new ButtonBuilder()
.setLabel("Cancel")
.setCustomId(`effects use cancel ${effectDetail.id}`)
.setStyle(ButtonStyle.Danger),
]);
await interaction.reply({
embeds: [ embed ],
components: [ row ],
});
}
}

View file

@ -0,0 +1,22 @@
import { CommandInteraction } from "discord.js";
import EffectHelper from "../../helpers/EffectHelper";
export default async function Buy(interaction: CommandInteraction) {
const id = interaction.options.get("id", true).value!;
const quantity = interaction.options.get("quantity")?.value ?? 1;
const idValue = id.toString();
const quantityValue = Number(quantity);
const result = await EffectHelper.GenerateEffectBuyEmbed(interaction.user.id, idValue, quantityValue, false);
if (typeof result == "string") {
await interaction.reply(result);
return;
}
await interaction.reply({
embeds: [ result.embed ],
components: [ result.row ],
});
}

View file

@ -0,0 +1,15 @@
import { CommandInteraction } from "discord.js";
import EffectHelper from "../../helpers/EffectHelper";
export default async function List(interaction: CommandInteraction) {
const pageOption = interaction.options.get("page");
const page = !isNaN(Number(pageOption?.value)) ? Number(pageOption?.value) : 1;
const result = await EffectHelper.GenerateEffectListEmbed(interaction.user.id, page);
await interaction.reply({
embeds: [ result.embed ],
components: [ result.row ],
});
}

View file

@ -0,0 +1,62 @@
import { ActionRowBuilder, ButtonBuilder, ButtonStyle, CommandInteraction, EmbedBuilder } from "discord.js";
import { EffectDetails } from "../../constants/EffectDetails";
import AppLogger from "../../client/appLogger";
import EffectHelper from "../../helpers/EffectHelper";
import TimeLengthInput from "../../helpers/TimeLengthInput";
import EmbedColours from "../../constants/EmbedColours";
export default async function Use(interaction: CommandInteraction) {
const id = interaction.options.get("id", true).value!.toString();
const effectDetail = EffectDetails.get(id);
if (!effectDetail) {
AppLogger.LogWarn("Commands/Effects", `Unable to find effect details for ${id}`);
await interaction.reply("Unable to find effect!");
return;
}
const canUseEffect = await EffectHelper.CanUseEffect(interaction.user.id, id);
if (!canUseEffect) {
await interaction.reply("Unable to use effect! Please make sure you have it in your inventory and is not on cooldown");
return;
}
const timeLengthInput = TimeLengthInput.ConvertFromMilliseconds(effectDetail.duration);
const embed = new EmbedBuilder()
.setTitle("Effect Confirmation")
.setDescription("Would you like to use this effect?")
.setColor(EmbedColours.Ok)
.addFields([
{
name: "Effect",
value: effectDetail.friendlyName,
inline: true,
},
{
name: "Length",
value: timeLengthInput.GetLengthShort(),
inline: true,
},
]);
const row = new ActionRowBuilder<ButtonBuilder>()
.addComponents([
new ButtonBuilder()
.setLabel("Confirm")
.setCustomId(`effects use confirm ${effectDetail.id}`)
.setStyle(ButtonStyle.Primary),
new ButtonBuilder()
.setLabel("Cancel")
.setCustomId(`effects use cancel ${effectDetail.id}`)
.setStyle(ButtonStyle.Danger),
]);
await interaction.reply({
embeds: [ embed ],
components: [ row ],
});
}

View file

@ -17,3 +17,7 @@ class EffectDetail {
export const EffectDetails = new Map<string, EffectDetail>([
[ "unclaimed", new EffectDetail("unclaimed", "Unclaimed Chance Up", 10 * 60 * 1000, 100, 3 * 60 * 60 * 1000) ],
]);
export const EffectChoices = [
{ name: "Unclaimed Chance Up", value: "unclaimed" },
];

View file

@ -2,6 +2,9 @@ import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } from "disc
import UserEffect from "../database/entities/app/UserEffect";
import EmbedColours from "../constants/EmbedColours";
import { EffectDetails } from "../constants/EffectDetails";
import User from "../database/entities/app/User";
import CardConstants from "../constants/CardConstants";
import AppLogger from "../client/appLogger";
export default class EffectHelper {
public static async AddEffectToUserInventory(userId: string, name: string, quantity: number = 1) {
@ -66,7 +69,7 @@ export default class EffectHelper {
return true;
}
public static async GenerateEffectEmbed(userId: string, page: number): Promise<{
public static async GenerateEffectListEmbed(userId: string, page: number): Promise<{
embed: EmbedBuilder,
row: ActionRowBuilder<ButtonBuilder>,
}> {
@ -126,4 +129,66 @@ export default class EffectHelper {
row,
};
}
public static async GenerateEffectBuyEmbed(userId: string, id: string, quantity: number, disabled: boolean): Promise<{
embed: EmbedBuilder,
row: ActionRowBuilder<ButtonBuilder>,
} | string> {
const effectDetail = EffectDetails.get(id);
if (!effectDetail) {
return "Effect detail not found!";
}
const totalCost = effectDetail.cost * quantity;
let user = await User.FetchOneById(User, userId);
if (!user) {
user = new User(userId, CardConstants.StartingCurrency);
await user.Save(User, user);
AppLogger.LogInfo("EffectHelper", `Created initial user entity for : ${userId}`);
}
if (user.Currency < totalCost) {
return `You don't have enough currency to buy this! You have \`${user.Currency} Currency\` and need \`${totalCost} Currency\`!`;
}
const embed = new EmbedBuilder()
.setTitle("Buy Effect")
.setDescription(effectDetail.friendlyName)
.setColor(EmbedColours.Ok)
.addFields([
{
name: "Cost",
value: `${totalCost}`,
inline: true,
},
{
name: "Quantity",
value: `${quantity}`,
inline: true,
},
]);
const row = new ActionRowBuilder<ButtonBuilder>()
.addComponents([
new ButtonBuilder()
.setCustomId(`effects buy confirm ${id} ${quantity}`)
.setLabel("Confirm")
.setStyle(ButtonStyle.Success)
.setDisabled(disabled),
new ButtonBuilder()
.setCustomId(`effects buy cancel ${id} ${quantity}`)
.setLabel("Cancel")
.setStyle(ButtonStyle.Danger)
.setDisabled(disabled),
]);
return {
embed,
row,
}
}
}

View file

@ -17,5 +17,7 @@ export default function GenerateButtonInteractionMock(): ButtonInteraction {
id: "userId",
},
customId: "customId",
update: jest.fn(),
reply: jest.fn(),
};
}

View file

@ -0,0 +1,12 @@
import { CommandInteraction } from "../../__types__/discord.js";
export default function GenerateCommandInteractionMock(options?: {
subcommand?: string,
}): CommandInteraction {
return {
isChatInputCommand: jest.fn().mockReturnValue(true),
options: {
getSubcommand: jest.fn().mockReturnValue(options?.subcommand),
},
};
}

View file

@ -14,4 +14,13 @@ export type ButtonInteraction = {
id: string,
} | null,
customId: string,
update: jest.Func,
reply: jest.Func,
}
export type CommandInteraction = {
isChatInputCommand: jest.Func,
options: {
getSubcommand: jest.Func,
},
}

View file

@ -49,6 +49,8 @@ test("GIVEN action is use, EXPECT use function to be called", async () => {
expect(List).not.toHaveBeenCalled();
});
test.todo("GIVEN action is buy, EXPECT buy function to be called");
test("GIVEN action is invalid, EXPECT nothing to be called", async () => {
// Arrange
interaction.customId = "effects invalid";
@ -63,4 +65,4 @@ test("GIVEN action is invalid, EXPECT nothing to be called", async () => {
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buttons/Effects", "Unknown action, invalid");
});
});

View file

@ -0,0 +1,350 @@
import {ButtonInteraction} from "discord.js";
import Buy from "../../../src/buttonEvents/Effects/Buy";
import GenerateButtonInteractionMock from "../../__functions__/discord.js/GenerateButtonInteractionMock";
import { ButtonInteraction as ButtonInteractionType } from "../../__types__/discord.js";
import AppLogger from "../../../src/client/appLogger";
import EffectHelper from "../../../src/helpers/EffectHelper";
import EmbedColours from "../../../src/constants/EmbedColours";
import User from "../../../src/database/entities/app/User";
jest.mock("../../../src/client/appLogger");
jest.mock("../../../src/helpers/EffectHelper");
jest.mock("../../../src/database/entities/app/User");
let interaction: ButtonInteractionType;
beforeEach(() => {
jest.resetAllMocks();
interaction = GenerateButtonInteractionMock();
interaction.customId = "effects buy";
});
describe("Execute", () => {
test("GIVEN subaction is invalid, EXPECT error logged", async () => {
// Arrange
interaction.customId += " invalid";
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy", "Unknown subaction, effects invalid");
});
});
describe("Confirm", () => {
let user: User;
beforeEach(() => {
interaction.customId += " confirm";
user = {
Currency: 1000,
Save: jest.fn(),
RemoveCurrency: jest.fn(),
} as unknown as User;
(User.FetchOneById as jest.Mock).mockResolvedValue(user);
});
test("EXPECT success embed generated", async () => {
// Assert
interaction.customId += " unclaimed 1";
const embed = {
id: "embed",
setColor: jest.fn(),
setFooter: jest.fn(),
};
const row = {
id: "row",
};
(EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue({
embed,
row,
});
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(interaction.update).toHaveBeenCalledTimes(1);
expect(interaction.update).toHaveBeenCalledWith({
embeds: [ embed ],
components: [ row ],
});
expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledTimes(1);
expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledWith("userId", "unclaimed", 1, true);
expect(embed.setColor).toHaveBeenCalledTimes(1);
expect(embed.setColor).toHaveBeenCalledWith(EmbedColours.Success);
expect(embed.setFooter).toHaveBeenCalledTimes(1);
expect(embed.setFooter).toHaveBeenCalledWith({ text: "Purchased" });
expect(interaction.reply).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
expect(User.FetchOneById).toHaveBeenCalledTimes(1);
expect(User.FetchOneById).toHaveBeenCalledWith(User, "userId");
expect(user.RemoveCurrency).toHaveBeenCalledTimes(1);
expect(user.RemoveCurrency).toHaveBeenCalledWith(100);
expect(user.Save).toHaveBeenCalledTimes(1);
expect(user.Save).toHaveBeenCalledWith(User, user);
expect(EffectHelper.AddEffectToUserInventory).toHaveBeenCalledTimes(1);
expect(EffectHelper.AddEffectToUserInventory).toHaveBeenCalledWith("userId", "unclaimed", 1);
});
test("GIVEN id is not supplied, EXPECT error", async () => {
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Confirm", "Not enough parameters");
expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN quantity is not supplied, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed";
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Confirm", "Not enough parameters");
expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN quantity is not a number, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed invalid";
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Confirm", "Invalid number");
expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN quantity is 0, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed 0";
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Confirm", "Invalid number");
expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN user is not found, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed 1";
(User.FetchOneById as jest.Mock).mockResolvedValue(undefined);
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Confirm", "Unable to find user");
expect(EffectHelper.AddEffectToUserInventory).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
});
test("GIVEN user does not have enough currency, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed 1";
user.Currency = 0;
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("You don't have enough currency to buy this! You have `0 Currency` and need `100 Currency`!");
expect(EffectHelper.AddEffectToUserInventory).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
});
test("GIVEN GenerateEffectBuyEmbed returns with a string, EXPECT error replied", async () => {
// Assert
interaction.customId += " unclaimed 1";
(EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue("Test error");
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Test error");
expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledTimes(1);
expect(interaction.update).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
});
});
describe("Cancel", () => {
beforeEach(() => {
interaction.customId += " cancel";
});
test("EXPECT embed generated", async () => {
// Assert
interaction.customId += " unclaimed 1";
const embed = {
id: "embed",
setColor: jest.fn(),
setFooter: jest.fn(),
};
const row = {
id: "row",
};
(EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue({
embed,
row,
});
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(interaction.update).toHaveBeenCalledTimes(1);
expect(interaction.update).toHaveBeenCalledWith({
embeds: [ embed ],
components: [ row ],
});
expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledTimes(1);
expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledWith("userId", "unclaimed", 1, true);
expect(embed.setColor).toHaveBeenCalledTimes(1);
expect(embed.setColor).toHaveBeenCalledWith(EmbedColours.Error);
expect(embed.setFooter).toHaveBeenCalledTimes(1);
expect(embed.setFooter).toHaveBeenCalledWith({ text: "Cancelled" });
expect(interaction.reply).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
});
test("GIVEN id is not supplied, EXPECT error", async () => {
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Not enough parameters");
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN quantity is not supplied, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed";
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Not enough parameters");
expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN quantity is not a number, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed invalid";
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Invalid number");
expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN quantity is 0, EXPECT error", async () => {
// Assert
interaction.customId += " unclaimed 0";
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Invalid number");
expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
expect(interaction.reply).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
test("GIVEN GenerateEffectBuyEmbed returns with a string, EXPECT error replied", async () => {
// Assert
interaction.customId += " unclaimed 1";
(EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue("Test error");
// Act
await Buy.Execute(interaction as unknown as ButtonInteraction);
// Assert
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Test error");
expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledTimes(1);
expect(interaction.update).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
});
});

View file

@ -10,7 +10,7 @@ let interaction: ReturnType<typeof mock<ButtonInteraction>>;
beforeEach(() => {
jest.resetAllMocks();
(EffectHelper.GenerateEffectEmbed as jest.Mock).mockResolvedValue({
(EffectHelper.GenerateEffectListEmbed as jest.Mock).mockResolvedValue({
embed: mock<EmbedBuilder>(),
row: mock<ActionRowBuilder<ButtonBuilder>>(),
});
@ -31,7 +31,7 @@ test("GIVEN pageOption is NOT a number, EXPECT error", async () => {
expect(interaction.reply).toHaveBeenCalledTimes(1);
expect(interaction.reply).toHaveBeenCalledWith("Page option is not a valid number")
expect(EffectHelper.GenerateEffectEmbed).not.toHaveBeenCalled();
expect(EffectHelper.GenerateEffectListEmbed).not.toHaveBeenCalled();
expect(interaction.update).not.toHaveBeenCalled();
});
@ -43,8 +43,8 @@ test("GIVEN pageOption is a number, EXPECT interaction updated", async () => {
await List(interaction);
// Assert
expect(EffectHelper.GenerateEffectEmbed).toHaveBeenCalledTimes(1);
expect(EffectHelper.GenerateEffectEmbed).toHaveBeenCalledWith("userId", 1);
expect(EffectHelper.GenerateEffectListEmbed).toHaveBeenCalledTimes(1);
expect(EffectHelper.GenerateEffectListEmbed).toHaveBeenCalledWith("userId", 1);
expect(interaction.update).toHaveBeenCalledTimes(1);
});

View file

@ -0,0 +1,106 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`EXPECT CommandBuilder to be defined 1`] = `
{
"contexts": undefined,
"default_member_permissions": undefined,
"default_permission": undefined,
"description": "Effects",
"description_localizations": undefined,
"dm_permission": undefined,
"integration_types": undefined,
"name": "effects",
"name_localizations": undefined,
"nsfw": undefined,
"options": [
{
"description": "List all effects I have",
"description_localizations": undefined,
"name": "list",
"name_localizations": undefined,
"options": [
{
"autocomplete": undefined,
"choices": undefined,
"description": "The page number",
"description_localizations": undefined,
"max_value": undefined,
"min_value": 1,
"name": "page",
"name_localizations": undefined,
"required": false,
"type": 10,
},
],
"type": 1,
},
{
"description": "Use an effect in your inventory",
"description_localizations": undefined,
"name": "use",
"name_localizations": undefined,
"options": [
{
"autocomplete": undefined,
"choices": [
{
"name": "Unclaimed Chance Up",
"name_localizations": undefined,
"value": "unclaimed",
},
],
"description": "The effect id to use",
"description_localizations": undefined,
"max_length": undefined,
"min_length": undefined,
"name": "id",
"name_localizations": undefined,
"required": true,
"type": 3,
},
],
"type": 1,
},
{
"description": "Buy more effects",
"description_localizations": undefined,
"name": "buy",
"name_localizations": undefined,
"options": [
{
"autocomplete": undefined,
"choices": [
{
"name": "Unclaimed Chance Up",
"name_localizations": undefined,
"value": "unclaimed",
},
],
"description": "The effect id to buy",
"description_localizations": undefined,
"max_length": undefined,
"min_length": undefined,
"name": "id",
"name_localizations": undefined,
"required": true,
"type": 3,
},
{
"autocomplete": undefined,
"choices": undefined,
"description": "The amount to buy",
"description_localizations": undefined,
"max_value": undefined,
"min_value": 1,
"name": "quantity",
"name_localizations": undefined,
"required": false,
"type": 10,
},
],
"type": 1,
},
],
"type": 1,
}
`;

View file

@ -0,0 +1,105 @@
import Effects from "../../src/commands/effects";
import List from "../../src/commands/effects/List";
import Use from "../../src/commands/effects/Use";
import Buy from "../../src/commands/effects/Buy";
import AppLogger from "../../src/client/appLogger";
import GenerateCommandInteractionMock from "../__functions__/discord.js/GenerateCommandInteractionMock";
import { CommandInteraction } from "discord.js";
jest.mock("../../src/commands/effects/List");
jest.mock("../../src/commands/effects/Use");
jest.mock("../../src/commands/effects/Buy");
jest.mock("../../src/client/appLogger");
beforeEach(() => {
jest.resetAllMocks();
});
test("EXPECT CommandBuilder to be defined", async () => {
// Act
const effects = new Effects();
// Assert
expect(effects.CommandBuilder).toMatchSnapshot();
});
describe("execute", () => {
test("GIVEN interaction subcommand is list, EXPECT buy function called", async () => {
// Arrange
const interaction = GenerateCommandInteractionMock({
subcommand: "list",
});
// Act
const effects = new Effects();
await effects.execute(interaction as unknown as CommandInteraction);
// Assert
expect(List).toHaveBeenCalledTimes(1);
expect(List).toHaveBeenCalledWith(interaction);
expect(Use).not.toHaveBeenCalled();
expect(Buy).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
});
test("GIVEN interaction subcommand is use, EXPECT buy function called", async () => {
// Arrange
const interaction = GenerateCommandInteractionMock({
subcommand: "use",
});
// Act
const effects = new Effects();
await effects.execute(interaction as unknown as CommandInteraction);
// Assert
expect(Use).toHaveBeenCalledTimes(1);
expect(Use).toHaveBeenCalledWith(interaction);
expect(List).not.toHaveBeenCalled();
expect(Buy).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
});
test("GIVEN interaction subcommand is buy, EXPECT buy function called", async () => {
// Arrange
const interaction = GenerateCommandInteractionMock({
subcommand: "buy",
});
// Act
const effects = new Effects();
await effects.execute(interaction as unknown as CommandInteraction);
// Assert
expect(Buy).toHaveBeenCalledTimes(1);
expect(Buy).toHaveBeenCalledWith(interaction);
expect(List).not.toHaveBeenCalled();
expect(Use).not.toHaveBeenCalled();
expect(AppLogger.LogError).not.toHaveBeenCalled();
});
test("GIVEN interaction subcommand is invalid, EXPECT error logged", async () => {
// Arrange
const interaction = GenerateCommandInteractionMock({
subcommand: "invalid",
});
// Act
const effects = new Effects();
await effects.execute(interaction as unknown as CommandInteraction);
// Assert
expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
expect(AppLogger.LogError).toHaveBeenCalledWith("Commands/Effects", "Invalid subcommand: invalid");
expect(List).not.toHaveBeenCalled();
expect(Use).not.toHaveBeenCalled();
expect(Buy).not.toHaveBeenCalled();
});
});

View file

@ -0,0 +1,9 @@
jest.mock("../../../src/helpers/EffectHelper");
describe("Buy", () => {
test.todo("GIVEN result returns a string, EXPECT interaction replied with string");
test.todo("GIVEN result returns an embed, EXPECT interaction replied with embed and row");
test.todo("GIVEN quantity option is not supplied, EXPECT quantity to default to 1");
});

View file

@ -3,7 +3,7 @@ import UserEffect from "../../src/database/entities/app/UserEffect";
jest.mock("../../src/database/entities/app/UserEffect");
describe("GenerateEffectEmbed", () => {
describe("GenerateEffectListEmbed", () => {
test("GIVEN user has an effect, EXPECT detailed embed to be returned", async () => {
// Arrange
(UserEffect.FetchAllByUserIdPaginated as jest.Mock).mockResolvedValue([
@ -17,7 +17,7 @@ describe("GenerateEffectEmbed", () => {
]);
// Act
const result = await EffectHelper.GenerateEffectEmbed("userId", 1);
const result = await EffectHelper.GenerateEffectListEmbed("userId", 1);
// Assert
expect(result).toMatchSnapshot();
@ -43,7 +43,7 @@ describe("GenerateEffectEmbed", () => {
]);
// Act
const result = await EffectHelper.GenerateEffectEmbed("userId", 1);
const result = await EffectHelper.GenerateEffectListEmbed("userId", 1);
// Assert
expect(result).toMatchSnapshot();
@ -69,7 +69,7 @@ describe("GenerateEffectEmbed", () => {
]);
// Act
const result = await EffectHelper.GenerateEffectEmbed("userId", 2);
const result = await EffectHelper.GenerateEffectListEmbed("userId", 2);
// Assert
expect(result).toMatchSnapshot();
@ -83,7 +83,7 @@ describe("GenerateEffectEmbed", () => {
]);
// Act
const result = await EffectHelper.GenerateEffectEmbed("userId", 1);
const result = await EffectHelper.GenerateEffectListEmbed("userId", 1);
// Assert
expect(result).toMatchSnapshot();
@ -107,9 +107,21 @@ describe("GenerateEffectEmbed", () => {
});
// Act
const result = await EffectHelper.GenerateEffectEmbed("userId", 1);
const result = await EffectHelper.GenerateEffectListEmbed("userId", 1);
// Assert
expect(result).toMatchSnapshot();
});
});
describe("GenerateEffectBuyEmbed", () => {
test.todo("GIVEN Effect Details are not found, EXPECT error");
test.todo("GIVEN user is not in database, EXPECT blank user created");
test.todo("GIVEN user does not have enough currency, EXPECT error");
test.todo("GIVEN user does have enough currency, EXPECT embed returned");
test.todo("GIVEN disabled boolean is true, EXPECT buttons to be disabled");
});

View file

@ -1,6 +1,6 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`GenerateEffectEmbed GIVEN there is an active effect, EXPECT field added 1`] = `
exports[`GenerateEffectListEmbed GIVEN there is an active effect, EXPECT field added 1`] = `
{
"embed": {
"color": 3166394,
@ -47,7 +47,7 @@ exports[`GenerateEffectEmbed GIVEN there is an active effect, EXPECT field added
}
`;
exports[`GenerateEffectEmbed GIVEN user does NOT have an effect, EXPECT empty embed to be returned 1`] = `
exports[`GenerateEffectListEmbed GIVEN user does NOT have an effect, EXPECT empty embed to be returned 1`] = `
{
"embed": {
"color": 3166394,
@ -82,7 +82,7 @@ exports[`GenerateEffectEmbed GIVEN user does NOT have an effect, EXPECT empty em
}
`;
exports[`GenerateEffectEmbed GIVEN user has an effect, EXPECT detailed embed to be returned 1`] = `
exports[`GenerateEffectListEmbed GIVEN user has an effect, EXPECT detailed embed to be returned 1`] = `
{
"embed": {
"color": 3166394,
@ -117,7 +117,7 @@ exports[`GenerateEffectEmbed GIVEN user has an effect, EXPECT detailed embed to
}
`;
exports[`GenerateEffectEmbed GIVEN user has more than 1 page of effects, EXPECT pagination enabled 1`] = `
exports[`GenerateEffectListEmbed GIVEN user has more than 1 page of effects, EXPECT pagination enabled 1`] = `
{
"embed": {
"color": 3166394,
@ -166,7 +166,7 @@ Unclaimed Chance Up x1",
}
`;
exports[`GenerateEffectEmbed GIVEN user is on a page other than 1, EXPECT pagination enabled 1`] = `
exports[`GenerateEffectListEmbed GIVEN user is on a page other than 1, EXPECT pagination enabled 1`] = `
{
"embed": {
"color": 3166394,