WIP: Start of config tests

src/commands/config.ts

@@ -61,7 +61,7 @@ export default class Config extends Command {
         ]);
 
         if (!server) {
-            await interaction.reply('Server not setup. Please use the setup command,');
+            await interaction.reply('Server not setup. Please use the setup command.');
             return;
         }
 

tests/commands/config.test.ts

@@ -1,15 +1,157 @@
+import { ChatInputCommandInteraction, PermissionsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandSubcommandBuilder } from "discord.js";
+import Command from "../../src/commands/config";
+import Server from "../../src/database/entities/Server";
+
 describe("constructor", () => {
-    test.todo("EXPECT properties to be set");
+    test("EXPECT properties to be set", () => {
+        const command = new Command();
+
+        expect(command.CommandBuilder).toBeDefined();
+
+        const commandBuilder = command.CommandBuilder as SlashCommandBuilder;
+
+        expect(commandBuilder.name).toBe("config");
+        expect(commandBuilder.description).toBe("Configure the current server");
+        expect(commandBuilder.default_member_permissions).toBe(PermissionsBitField.Flags.Administrator.toString());
+        expect(commandBuilder.options.length).toBe(4);
+
+        const commandBuilderResetSubcommand = commandBuilder.options[0] as SlashCommandSubcommandBuilder;
+
+        expect(commandBuilderResetSubcommand.name).toBe("reset");
+        expect(commandBuilderResetSubcommand.description).toBe("Reset a setting to the default");
+        expect(commandBuilderResetSubcommand.options.length).toBe(1);
+
+        const commandBuilderResetSubcommandKeyOption = commandBuilderResetSubcommand.options[0] as SlashCommandStringOption;
+
+        expect(commandBuilderResetSubcommandKeyOption.name).toBe("key");
+        expect(commandBuilderResetSubcommandKeyOption.description).toBe("The key");
+        expect(commandBuilderResetSubcommandKeyOption.required).toBe(true);
+
+        const commandBuilderGetSubcommand = commandBuilder.options[1] as SlashCommandSubcommandBuilder;
+
+        expect(commandBuilderGetSubcommand.name).toBe("get");
+        expect(commandBuilderGetSubcommand.description).toBe("Gets a setting for the server");
+        expect(commandBuilderGetSubcommand.options.length).toBe(1);
+
+        const commandBuilderGetSubcommandKeyOption = commandBuilderGetSubcommand.options[0] as SlashCommandStringOption;
+
+        expect(commandBuilderGetSubcommandKeyOption.name).toBe("key");
+        expect(commandBuilderGetSubcommandKeyOption.description).toBe("The key");
+        expect(commandBuilderGetSubcommandKeyOption.required).toBe(true);
+
+        const commandBuilderSetSubcommand = commandBuilder.options[2] as SlashCommandSubcommandBuilder;
+
+        expect(commandBuilderSetSubcommand.name).toBe("set");
+        expect(commandBuilderSetSubcommand.description).toBe("Sets a setting to a specified value");
+        expect(commandBuilderSetSubcommand.options.length).toBe(2);
+
+        const commandBuilderSetSubcommandKeyOption = commandBuilderSetSubcommand.options[0] as SlashCommandStringOption;
+
+        expect(commandBuilderSetSubcommandKeyOption.name).toBe("key");
+        expect(commandBuilderSetSubcommandKeyOption.description).toBe("The key");
+        expect(commandBuilderSetSubcommandKeyOption.required).toBe(true);
+
+        const commandBuilderSetSubcommandValueOption = commandBuilderSetSubcommand.options[1] as SlashCommandStringOption;
+
+        expect(commandBuilderSetSubcommandValueOption.name).toBe("value");
+        expect(commandBuilderSetSubcommandValueOption.description).toBe("The value");
+        expect(commandBuilderSetSubcommandValueOption.required).toBe(true);
+
+        const commandBuilderListSubcommand = commandBuilder.options[3] as SlashCommandSubcommandBuilder;
+
+        expect(commandBuilderListSubcommand.name).toBe("list");
+        expect(commandBuilderListSubcommand.description).toBe("Lists all settings");
+    });
 });
 
 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 () => {
+        // Arrange
+        const interaction = {
+            isChatInputCommand: jest.fn().mockReturnValue(false),
+            options: {
+                getSubcommand: jest.fn(),
+            },
+        } as unknown as ChatInputCommandInteraction;
 
-    test.todo("GIVEN interaction.guildId is null, EXPECT nothing to happen");
+        // Act
+        const command = new Command();
+        await command.execute(interaction);
 
-    test.todo("GIVEN server is not set up in the database, EXPECT error");
+        // Assert
+        expect(interaction.isChatInputCommand).toHaveBeenCalledTimes(1);
+        expect(interaction.options.getSubcommand).not.toHaveBeenCalled();
+    });
 
-    test.todo("GIVEN subcommand is invalid, EXPECT error");
+    test("GIVEN interaction.guildId is null, EXPECT nothing to happen", async () => {
+        // Arrange
+        const interaction = {
+            isChatInputCommand: jest.fn().mockReturnValue(true),
+            options: {
+                getSubcommand: jest.fn(),
+            },
+            guildId: null,
+        } as unknown as ChatInputCommandInteraction;
+
+        // Act
+        const command = new Command();
+        await command.execute(interaction);
+
+        // Assert
+        expect(interaction.isChatInputCommand).toHaveBeenCalledTimes(1);
+        expect(interaction.options.getSubcommand).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN server is not set up in the database, EXPECT error", async () => {
+        // Arrange
+        const interaction = {
+            isChatInputCommand: jest.fn().mockReturnValue(true),
+            options: {
+                getSubcommand: jest.fn(),
+            },
+            guildId: "guildId",
+            reply: jest.fn(),
+        } as unknown as ChatInputCommandInteraction;
+
+        Server.FetchOneById = jest.fn().mockResolvedValue(null);
+
+        // Act
+        const command = new Command();
+        await command.execute(interaction);
+
+        // Assert
+        expect(Server.FetchOneById).toHaveBeenCalledTimes(1);
+        expect(Server.FetchOneById).toHaveBeenCalledWith(Server, "guildId", [ "Settings" ]);
+
+        expect(interaction.reply).toHaveBeenCalledTimes(1);
+        expect(interaction.reply).toHaveBeenCalledWith("Server not setup. Please use the setup command.");
+
+        expect(interaction.options.getSubcommand).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN subcommand is invalid, EXPECT error", async () => {
+        // Arrange
+        const interaction = {
+            isChatInputCommand: jest.fn().mockReturnValue(true),
+            options: {
+                getSubcommand: jest.fn().mockReturnValue("invalid"),
+            },
+            guildId: "guildId",
+            reply: jest.fn(),
+        } as unknown as ChatInputCommandInteraction;
+
+        Server.FetchOneById = jest.fn().mockResolvedValue({});
+
+        // Act
+        const command = new Command();
+        await command.execute(interaction);
+
+        // Assert
+        expect(interaction.options.getSubcommand).toHaveBeenCalledTimes(1);
+
+        expect(interaction.reply).toHaveBeenCalledTimes(1);
+        expect(interaction.reply).toHaveBeenCalledWith("Subcommand not found.");
+    });
 });
 
 describe("list", () => {