package.json

@@ -7,7 +7,7 @@
     "clean": "rm -rf node_modules/ dist/",
     "build": "tsc",
     "start": "node ./dist/bot.js",
-    "test": "jest",
+    "test": "echo true",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "db:up": "typeorm migration:run -d dist/database/dataSources/appDataSource.js",

src/database/entities/app/UserEffect.ts

@@ -1,6 +1,5 @@
 import {Column, Entity} from "typeorm";
 import AppBaseEntity from "../../../contracts/AppBaseEntity";
-import AppDataSource from "../../dataSources/appDataSource";
 
 @Entity()
 export default class UserEffect extends AppBaseEntity {
@@ -49,12 +48,4 @@ export default class UserEffect extends AppBaseEntity {
 
         return false;
     }
-
-    public static async FetchOneByUserIdAndName(userId: string, name: string): Promise<UserEffect | null> {
-        const repository = AppDataSource.getRepository(UserEffect);
-
-        const single = await repository.findOne({ where: { UserId: userId, Name: name } });
-
-        return single;
-    }
 }

src/helpers/EffectHelper.ts

@@ -1,49 +0,0 @@
-import UserEffect from "../database/entities/app/UserEffect";
-
-export default class EffectHelper {
-    public static async AddEffectToUserInventory(userId: string, name: string, quantity: number = 1) {
-        let effect = await UserEffect.FetchOneByUserIdAndName(userId, name);
-
-        if (!effect) {
-            effect = new UserEffect(name, userId, quantity);
-        } else {
-            effect.AddUnused(quantity);
-        }
-
-        await effect.Save(UserEffect, effect);
-    }
-
-    public static async UseEffect(userId: string, name: string, whenExpires: Date): Promise<boolean> {
-        const effect = await UserEffect.FetchOneByUserIdAndName(userId, name);
-        const now = new Date();
-
-        if (!effect || effect.Unused == 0) {
-            return false;
-        }
-
-        if (effect.WhenExpires && now < effect.WhenExpires) {
-            return false;
-        }
-
-        effect.UseEffect(whenExpires);
-
-        await effect.Save(UserEffect, effect);
-
-        return true;
-    }
-
-    public static async HasEffect(userId: string, name: string): Promise<boolean> {
-        const effect = await UserEffect.FetchOneByUserIdAndName(userId, name);
-        const now = new Date();
-
-        if (!effect || !effect.WhenExpires) {
-            return false;
-        }
-
-        if (now > effect.WhenExpires) {
-            return false;
-        }
-
-        return true;
-    }
-}

tests/database/entities/app/UserEffect.test.ts

@@ -1,41 +0,0 @@
-describe("AddUnused", () => {
-    test.todo("EXPECT unused to be the amount more");
-});
-
-describe("UseEffect", () => {
-    describe("GIVEN Unused is 0", () => {
-        test.todo("EXPECT false returned");
-    });
-
-    describe("GIVEN Unused is greater than 0", () => {
-        test.todo("EXPECT true returned");
-
-        test.todo("EXPECT Unused to be subtracted by 1");
-
-        test.todo("EXPECT WhenExpires to be set");
-    });
-});
-
-describe("IsEffectActive", () => {
-    describe("GIVEN WhenExpires is null", () => {
-        test.todo("EXPECT false returned");
-    });
-
-    describe("GIVEN WhenExpires is defined", () => {
-        describe("AND WhenExpires is in the past", () => {
-            test.todo("EXPECT false returned");
-        });
-
-        describe("AND WhenExpires is in the future", () => {
-            test.todo("EXPECT true returned");
-        });
-    });
-});
-
-describe("FetchOneByUserIdAndName", () => {
-    test.todo("EXPECT entity to be returned");
-
-    test.todo("EXPECT AppDataSource.getRepository to have been called");
-
-    test.todo("EXPECT repository.findOne to have been called");
-});

tests/registry.test.ts

@@ -0,0 +1,66 @@
+import {CoreClient} from "../src/client/client";
+import Registry from "../src/registry";
+import fs from "fs";
+import path from "path";
+
+describe("RegisterCommands", () => {
+    test("EXPECT every command in the commands folder to be registered", () => {
+        const registeredCommands: string[] = [];
+
+        CoreClient.RegisterCommand = jest.fn().mockImplementation((name: string) => {
+            registeredCommands.push(name);
+        });
+
+        Registry.RegisterCommands();
+
+        const commandFiles = getFilesInDirectory(path.join(process.cwd(), "src", "commands"))
+            .filter(x => x.endsWith(".ts"));
+
+        for (const file of commandFiles) {
+            expect(registeredCommands).toContain(file.split("/").pop()!.split(".")[0]);
+        }
+
+        expect(commandFiles.length).toBe(registeredCommands.length);
+    });
+});
+
+describe("RegisterButtonEvents", () => {
+    test("EXEPCT every button event in the button events folder to be registered", () => {
+        const registeredButtonEvents: string[] = [];
+
+        CoreClient.RegisterButtonEvent = jest.fn().mockImplementation((name: string) => {
+            registeredButtonEvents.push(name);
+        });
+
+        Registry.RegisterButtonEvents();
+
+        const eventFiles = getFilesInDirectory(path.join(process.cwd(), "src", "buttonEvents"))
+            .filter(x => x.endsWith(".ts"));
+
+        for (const file of eventFiles) {
+            expect(registeredButtonEvents).toContain(file.split("/").pop()!.split(".")[0].toLowerCase());
+        }
+
+        expect(eventFiles.length).toBe(registeredButtonEvents.length);
+    });
+});
+
+function getFilesInDirectory(dir: string): string[] {
+    let results: string[] = [];
+    const list = fs.readdirSync(dir);
+
+    list.forEach(file => {
+        file = path.join(dir, file);
+        const stat = fs.statSync(file);
+
+        if (stat && stat.isDirectory()) {
+            /* recurse into a subdirectory */
+            results = results.concat(getFilesInDirectory(file));
+        } else {
+            /* is a file */
+            results.push(file);
+        }
+    });
+
+    return results;
+}