Merge pull request #44 from Vylpes/feature/tests

Tests and CI

.eslintignore

@@ -1 +1,2 @@
-tests
+node_modules
+dist

.eslintrc

@@ -1,44 +1,14 @@
 {
-    "parserOptions": {
-        "ecmaVersion": 6
-    },
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "@typescript-eslint"
+    ],
     "extends": [
-        "eslint:recommended"
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended"
     ],
-    "rules": {
-        "camelcase": "error",
-        "brace-style": [
-            "error",
-            "1tbs"
-        ],
-        "comma-dangle": [
-            "error",
-            "never"
-        ],
-        "comma-spacing": [
-            "error",
-            {
-                "before": false,
-                "after": true
-            }
-        ],
-        "comma-style": [
-            "error",
-            "last"
-        ],
-        "arrow-body-style": [
-            "error",
-            "as-needed"
-        ],
-        "arrow-parens": [
-            "error",
-            "as-needed"
-        ],
-        "arrow-spacing": "error",
-        "no-var": "error",
-        "prefer-template": "error",
-        "prefer-const": "error"
-    },
     "globals": {
         "exports": "writable",
         "module": "writable",
@@ -46,4 +16,4 @@
         "process": "writable",
         "console": "writable"
     }
-}
+  }

.gitignore

@@ -108,8 +108,8 @@ commands/
 events/
 /bot.ts
 
-!tests/commands/
-!tests/events/
+!tests/__mocks/commands
+!tests/__mocks/events
 
 # Linux Environment Files
 *.swp

jest.config.js

@@ -1,3 +1,5 @@
+/** @type {import('@ts-jest/dist/types').InitialOptionsTsJest} */
 module.exports = {
-    testEnvironment: 'node'
-}
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package.json

@@ -6,8 +6,7 @@
   "scripts": {
     "build": "tsc",
     "test": "jest --coverage",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint": "eslint ."
   },
   "author": "Vylpes",
   "license": "MIT",
@@ -25,7 +24,13 @@
   ],
   "repository": "github:vylpes/vylbot-core",
   "devDependencies": {
+    "@types/jest": "^26.0.24",
     "@types/node": "^16.3.2",
+    "@typescript-eslint/eslint-plugin": "^4.29.2",
+    "@typescript-eslint/parser": "^4.29.2",
+    "eslint": "^7.32.0",
+    "jest": "^27.0.6",
+    "ts-jest": "^27.0.4",
     "typescript": "^4.3.5"
   }
 }

src/client/events.ts

@@ -21,11 +21,6 @@ export class Events {
     // Emit when a message is sent
     // Used to check for commands
     public onMessage(message: Message): IEventResponse {
-        if (!message) return {
-            valid: false,
-            message: "Message was not supplied.",
-        };
-
         if (!message.guild) return {
             valid: false,
             message: "Message was not sent in a guild, ignoring.",
@@ -50,7 +45,7 @@ export class Events {
             const res = this._util.loadCommand(name, args, message);
 
             if (!res.valid) {
-                if (res.message != 'File does not exist') return {
+                return {
                     valid: false,
                     message: res.message,
                 };

src/client/util.ts

@@ -70,7 +70,7 @@ export class Util {
         } else {
             return {
                 valid: false,
-                message: "Comamnd folder does not exist",
+                message: "Command folder does not exist",
             }
         }
     }

tests/__mocks/commands/noCategory.ts

@@ -0,0 +1,7 @@
+import { Command } from "../../../src/type/command";
+
+export class noCategory extends Command {
+    constructor() {
+        super();
+    }
+}

tests/__mocks/commands/normal.ts

@@ -0,0 +1,8 @@
+import { Command } from "../../../src/type/command";
+
+export class normal extends Command {
+    constructor() {
+        super();
+        this._category = "General";
+    }
+}

tests/__mocks/commands/roles.ts

@@ -0,0 +1,8 @@
+import { Command } from "../../../src/type/command";
+
+export class roles extends Command {
+    constructor() {
+        super();
+        this._roles = [ "Moderator" ];
+    }
+}

tests/__mocks/events/normal.ts

@@ -0,0 +1,5 @@
+import { Event } from "../../../src/type/event";
+
+export class normal extends Event {
+    public override channelCreate() {}
+}

tests/client/client.test.ts

@@ -0,0 +1,139 @@
+import { CoreClient } from "../../src/client/client";
+
+import { Client } from "discord.js";
+import * as dotenv from "dotenv";
+import { Events } from "../../src/client/events";
+import { Util } from "../../src/client/util";
+
+jest.mock("discord.js");
+jest.mock("dotenv");
+jest.mock("../../src/client/events");
+jest.mock("../../src/client/util");
+
+describe('Constructor', () => {
+    test('Constructor_ExpectSuccessfulInitialisation', () => {
+        const coreClient = new CoreClient();
+    
+        expect(coreClient).toBeInstanceOf(Client);
+        expect(dotenv.config).toBeCalledTimes(1);
+        expect(Events).toBeCalledTimes(1);
+        expect(Util).toBeCalledTimes(1);
+    });
+});
+
+describe('Start', () => {
+    test('Given Env Is Valid, Expect Successful Start', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).not.toThrow();
+        expect(coreClient.on).toBeCalledWith("message", expect.any(Function));
+        expect(coreClient.on).toBeCalledWith("ready", expect.any(Function));
+    });
+    
+    test('Given BOT_TOKEN Is Null, Expect Failure', () => {
+        process.env = {
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("BOT_TOKEN is not defined in .env");
+    });
+    
+    test('Given BOT_TOKEN Is Empty, Expect Failure', () => {
+        process.env = {
+            BOT_TOKEN: '',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("BOT_TOKEN is not defined in .env");
+    });
+    
+    test('Given BOT_PREFIX Is Null, Expect Failure', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("BOT_PREFIX is not defined in .env");
+    });
+    
+    test('Given BOT_PREFIX Is Empty, Expect Failure', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("BOT_PREFIX is not defined in .env");
+    });
+    
+    test('Given FOLDERS_COMMANDS Is Null, Expect Failure', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("FOLDERS_COMMANDS is not defined in .env");
+    });
+    
+    test('Given FOLDERS_COMMANDS Is Empty, Expect Failure', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: '',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("FOLDERS_COMMANDS is not defined in .env");
+    });
+    
+    test('Given FOLDERS_EVENTS Is Null, Expect Failure', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("FOLDERS_EVENTS is not defined in .env");
+    });
+    
+    test('Given FOLDERS_EVENTS Is Empty, Expect Failure', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: '',
+        }
+    
+        const coreClient = new CoreClient();
+        
+        expect(() => coreClient.start()).toThrow("FOLDERS_EVENTS is not defined in .env");
+    });
+});

tests/client/events.test.ts

@@ -0,0 +1,185 @@
+import { Events } from "../../src/client/events";
+
+import { Message, Client, TextChannel, Guild, SnowflakeUtil, DMChannel } from "discord.js";
+import { Util } from "../../src/client/util";
+
+jest.mock("../../src/client/util");
+
+beforeEach(() => {
+    Util.prototype.loadCommand = jest.fn();
+});
+
+describe('OnMessage', () => {
+    test('Given Message Is Valid Expect Message Sent', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        };
+    
+        Util.prototype.loadCommand = jest.fn().mockReturnValue({ valid: true });
+    
+        const message = {
+            guild: {},
+            author: {
+                bot: false,
+            },
+            content: "!test first",
+        } as unknown as Message;
+    
+        const events = new Events();
+    
+        const result = events.onMessage(message);
+    
+        expect(result.valid).toBeTruthy();
+    
+        expect(result.context?.prefix).toBe('!');
+        expect(result.context?.name).toBe('test');
+        expect(result.context?.args.length).toBe(1);
+        expect(result.context?.args[0]).toBe('first');
+        expect(result.context?.message).toBe(message);
+    });
+    
+    test('Given Guild Is Null, Expect Failed Result', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        Util.prototype.loadCommand = jest.fn().mockReturnValue({ valid: true });
+    
+        const message = {
+            guild: null,
+            author: {
+                bot: false,
+            },
+            content: "!test first",
+        } as unknown as Message;
+    
+        const events = new Events();
+    
+        const result = events.onMessage(message);
+    
+        expect(result.valid).toBeFalsy();
+        expect(result.message).toBe("Message was not sent in a guild, ignoring.");
+    });
+    
+    test('Given Author Is A Bot, Expect Failed Result', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        Util.prototype.loadCommand = jest.fn().mockReturnValue({ valid: true });
+    
+        const message = {
+            guild: {},
+            author: {
+                bot: true,
+            },
+            content: "!test first",
+        } as unknown as Message;
+    
+        const events = new Events();
+    
+        const result = events.onMessage(message);
+    
+        expect(result.valid).toBeFalsy();
+        expect(result.message).toBe("Message was sent by a bot, ignoring.");
+    });
+    
+    test('Given Message Content Was Not A Command, Expect Failed Result', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        Util.prototype.loadCommand = jest.fn().mockReturnValue({ valid: true });
+    
+        const message = {
+            guild: {},
+            author: {
+                bot: false,
+            },
+            content: "This is a standard message",
+        } as unknown as Message;
+    
+        const events = new Events();
+    
+        const result = events.onMessage(message);
+    
+        expect(result.valid).toBeFalsy();
+        expect(result.message).toBe("Message was not a command, ignoring.");
+    });
+    
+    test('Given Message Had No Command Name, Expect Failed Result', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        Util.prototype.loadCommand = jest.fn().mockReturnValue({ valid: true });
+    
+        const message = {
+            guild: {},
+            author: {
+                bot: false,
+            },
+            content: "!",
+        } as unknown as Message;
+    
+        const events = new Events();
+    
+        const result = events.onMessage(message);
+    
+        expect(result.valid).toBeFalsy();
+        expect(result.message).toBe("Command name was not found");
+    });
+    
+    test('Given Command Failed To Execute, Expect Failed Result', () => {
+        process.env = {
+            BOT_TOKEN: 'TOKEN',
+            BOT_PREFIX: '!',
+            FOLDERS_COMMANDS: 'commands',
+            FOLDERS_EVENTS: 'events',
+        }
+    
+        Util.prototype.loadCommand = jest.fn().mockReturnValue({ valid: false, message: "Command failed" });
+    
+        const message = {
+            guild: {},
+            author: {
+                bot: false,
+            },
+            content: "!test first",
+        } as unknown as Message;
+    
+        const events = new Events();
+    
+        const result = events.onMessage(message);
+    
+        expect(result.valid).toBeFalsy();
+        expect(result.message).toBe("Command failed");
+    });
+});
+
+describe('OnReady', () => {
+    test('Expect Console Log', () => {
+        console.log = jest.fn();
+    
+        const events = new Events();
+    
+        events.onReady();
+    
+        expect(console.log).toBeCalledWith("Ready");
+    });
+});

tests/client/util.test.ts

@@ -0,0 +1,291 @@
+import { Util } from "../../src/client/util";
+
+import { Client, Guild, Message, Role, SnowflakeUtil, TextChannel, User } from "discord.js";
+import fs from "fs";
+
+jest.mock("fs");
+
+beforeEach(() => {
+  fs.existsSync = jest.fn();
+});
+
+describe('LoadCommand', () => {
+  test('Given Successful Exection, Expect Successful Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+    
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(true);
+  
+    const message = {
+      member: {
+        roles: {
+          cache: {
+            find: jest.fn().mockReturnValue(true),
+          }
+        },
+      },
+      reply: jest.fn(),
+    } as unknown as Message;
+  
+    const util = new Util();
+  
+    const result = util.loadCommand("normal", [ "first" ], message);
+  
+    expect(result.valid).toBeTruthy();
+  });
+  
+  test('Given Member Is Null, Expect Failed Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+    
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(true);
+  
+    const message = {
+      member: null
+    } as unknown as Message;
+  
+    const util = new Util();
+  
+    const result = util.loadCommand("normal", [ "first" ], message);
+  
+    expect(result.valid).toBeFalsy();
+    expect(result.message).toBe("Member is not part of message");
+  });
+  
+  test('Given Folder Does Not Exist, Expect Failed Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+    
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(false);
+  
+    const message = {
+      member: {
+        roles: {
+          cache: {
+            find: jest.fn().mockReturnValue(true),
+          }
+        },
+      },
+      reply: jest.fn(),
+    } as unknown as Message;
+  
+    const util = new Util();
+  
+    const result = util.loadCommand("normal", [ "first" ], message);
+  
+    expect(result.valid).toBeFalsy();
+    expect(result.message).toBe("Command folder does not exist");
+  });
+  
+  test('Given File Does Not Exist, Expect Failed Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+    
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValueOnce(true)
+      .mockReturnValue(false);
+  
+      const message = {
+        member: {
+          roles: {
+            cache: {
+              find: jest.fn().mockReturnValue(true),
+            }
+          },
+        },
+        reply: jest.fn(),
+      } as unknown as Message;
+  
+    const util = new Util();
+  
+    const result = util.loadCommand("normal", [ "first" ], message);
+  
+    expect(result.valid).toBeFalsy();
+    expect(result.message).toBe("File does not exist");
+  });
+  
+  test('Given User Does Have Role, Expect Successful Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+    
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(true);
+  
+    const message = {
+      member: {
+        roles: {
+          cache: {
+            find: jest.fn().mockReturnValue(true),
+          }
+        },
+      },
+      reply: jest.fn(),
+    } as unknown as Message;
+  
+    const util = new Util();
+  
+    const result = util.loadCommand("roles", [ "first" ], message);
+  
+    expect(result.valid).toBeTruthy();
+  });
+  
+  test('Given User Does Not Have Role, Expect Failed Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+    
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(true);
+  
+    const message = {
+      member: {
+        roles: {
+          cache: {
+            find: jest.fn().mockReturnValue(false),
+          }
+        },
+      },
+      reply: jest.fn(),
+    } as unknown as Message;
+  
+    const util = new Util();
+  
+    const result = util.loadCommand("roles", [ "first" ], message);
+  
+    expect(result.valid).toBeFalsy();
+    expect(result.message).toBe("You require the `Moderator` role to run this command");
+  });
+  
+  test('Given Command Category Is Null, Expect Successful Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+    
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(true);
+  
+    const message = {
+      member: {
+        roles: {
+          cache: {
+            find: jest.fn().mockReturnValue(true),
+          }
+        },
+      },
+      reply: jest.fn(),
+    } as unknown as Message;
+  
+    const util = new Util();
+  
+    const result = util.loadCommand("noCategory", [ "first" ], message);
+  
+    expect(result.valid).toBeTruthy();
+  });
+});
+
+describe('LoadEvents', () => {
+  test('Given Events Are Loaded, Expect Successful Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+  
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(true);
+    fs.readdirSync = jest.fn().mockReturnValue(["normal.ts"]);
+  
+    const client = {
+      on: jest.fn(),
+    } as unknown as Client;
+  
+    const util = new Util();
+  
+    const result = util.loadEvents(client);
+  
+    const clientOn = jest.spyOn(client, 'on');
+  
+    expect(result.valid).toBeTruthy();
+    expect(clientOn).toBeCalledTimes(13);
+  });
+  
+  test('Given No Events Found, Expect Successful Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+  
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(true);
+    fs.readdirSync = jest.fn().mockReturnValue(["normal"]);
+  
+    const client = {
+      on: jest.fn(),
+    } as unknown as Client;
+  
+    const util = new Util();
+  
+    const result = util.loadEvents(client);
+  
+    const clientOn = jest.spyOn(client, 'on');
+  
+    expect(result.valid).toBeTruthy();
+    expect(clientOn).toBeCalledTimes(0);
+  });
+  
+  test('Given Event Folder Does Not Exist, Expect Failed Result', () => {
+    process.env = {
+      BOT_TOKEN: 'TOKEN',
+      BOT_PREFIX: '!',
+      FOLDERS_COMMANDS: 'commands',
+      FOLDERS_EVENTS: 'events',
+    }
+  
+    process.cwd = jest.fn().mockReturnValue("../../tests/__mocks");
+    fs.existsSync = jest.fn().mockReturnValue(false);
+    fs.readdirSync = jest.fn().mockReturnValue(["normal.ts"]);
+  
+    const client = {
+      on: jest.fn(),
+    } as unknown as Client;
+  
+    const util = new Util();
+  
+    const result = util.loadEvents(client);
+  
+    expect(result.valid).toBeFalsy();
+    expect(result.message).toBe("Event folder does not exist");
+  });
+});

tsconfig.json

@@ -71,5 +71,8 @@
   },
   "include": [
     "./src",
+  ],
+  "exclude": [
+    "./tests"
   ]
 }