Command to allow the user to buy more effects (#424)

# 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>

src/buttonEvents/Effects.ts

@@ -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}`);
         }

src/buttonEvents/Effects/Buy.ts

@@ -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 ],
+        });
+    }
+}

src/buttonEvents/Effects/List.ts

@@ -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 ],

src/commands/effects.ts

@@ -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 { EffectChoices } from "../constants/EffectDetails";
-import { EffectDetails } from "../constants/EffectDetails";
-import TimeLengthInput from "../helpers/TimeLengthInput";
-import EmbedColours from "../constants/EmbedColours";
 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([
+                    .setChoices(EffectChoices)))
-                        { name: "Unclaimed Chance Up", value: "unclaimed" },
+            .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 ],
-        });
-    }
 }

src/commands/effects/Buy.ts

@@ -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 ],
+    });
+}

src/commands/effects/List.ts

@@ -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 ],
+    });
+}

src/commands/effects/Use.ts

@@ -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 ],
+    });
+}

src/constants/EffectDetails.ts

@@ -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" },
+];

src/helpers/EffectHelper.ts

@@ -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,
+        }
+    }
 }

tests/__functions__/discord.js/GenerateButtonInteractionMock.ts

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

tests/__functions__/discord.js/GenerateCommandInteractionMock.ts

@@ -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),
+        },
+    };
+}

tests/__types__/discord.js.ts

@@ -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,
+    },
 }

tests/buttonEvents/Effects.test.ts

@@ -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");
-});
+});

tests/buttonEvents/Effects/Buy.test.ts

@@ -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();
+    });
+});

tests/buttonEvents/Effects/List.test.ts

@@ -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.GenerateEffectListEmbed).toHaveBeenCalledTimes(1);
-    expect(EffectHelper.GenerateEffectEmbed).toHaveBeenCalledWith("userId", 1);
+    expect(EffectHelper.GenerateEffectListEmbed).toHaveBeenCalledWith("userId", 1);
 
     expect(interaction.update).toHaveBeenCalledTimes(1);
 });

tests/commands/__snapshots__/effects.test.ts.snap

@@ -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,
+}
+`;

tests/commands/effects.test.ts

@@ -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();
+    });
+});

tests/commands/effects/Buy.test.ts

@@ -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");
+});

tests/helpers/EffectHelper.test.ts

@@ -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");
 });

tests/helpers/__snapshots__/EffectHelper.test.ts.snap

@@ -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,