Feature/14 create unit tests

.dockerignore

@@ -0,0 +1,4 @@
+node_modules/
+logs/
+local-cache/
+coverage/

.eslintrc.json

@@ -2,7 +2,7 @@
   "env": {
     "es2021": true,
     "node": true,
-    "mocha": true
+    "jest": true
   },
   "extends": ["airbnb-base"],
   "parser": "@typescript-eslint/parser",

.gitignore

@@ -1,5 +1,6 @@
 node_modules/
 logs/
 .env
-local-cache/*
-data/*
+local-cache/
+data/
+coverage/

.vscode/launch.json

@@ -33,6 +33,26 @@
       "console": "integratedTerminal",
       "sourceMaps": true,
       "internalConsoleOptions": "neverOpen"
+    },
+    {
+      "name": "Jest (debug) - Unit Test",
+      "type": "node",
+      "request": "launch",
+      "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/jest",
+      "args": [
+        "${fileBasenameNoExtension}",
+        "--runInBand",
+        "--watch",
+        "--coverage=false",
+        "--no-cache"
+      ],
+      "cwd": "${workspaceRoot}",
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "sourceMaps": true,
+      "windows": {
+        "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+      }
     }
   ]
 }

bot/commands/DivideByZeroCommand.spec.ts

@@ -0,0 +1,64 @@
+// reflect-metadata should be imported
+// before any interface or other imports
+// also it should be imported only once
+// so that a singleton is created.
+import 'reflect-metadata';
+import { ChatClient, ChatUser } from '@twurple/chat';
+import { Container } from 'inversify';
+import winston from 'winston';
+import { mockChatClient, mockLogger } from '../../tests/common.mocks';
+import InjectionTypes from '../../dependency-management/types';
+import { ICommandHandler } from './iCommandHandler';
+import { DivideByZeroCommand } from './DivideByZeroCommand';
+
+describe(' Divide By Zero Command Tests', () => {
+    const channel = 'TestChannel';
+    const command = 'TestCommand';
+    const message = 'TestMessage';
+    const user = <ChatUser>{ displayName: 'TestUser' };
+
+    const container: Container = new Container();
+    let expectedChatClient: ChatClient;
+    let expectedLogger: winston.Logger;
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        container.unbindAll();
+        container
+            .bind<ChatClient>(ChatClient)
+            .toConstantValue(mockChatClient);
+
+        container
+            .bind<winston.Logger>(InjectionTypes.Logger)
+            .toConstantValue(mockLogger);
+
+        container
+            .bind<ICommandHandler>(InjectionTypes.CommandHandlers)
+            .to(DivideByZeroCommand);
+
+        expectedChatClient = container
+            .get(ChatClient);
+
+        expectedLogger = container
+            .get<winston.Logger>(InjectionTypes.Logger);
+    });
+
+    it('should say something in chat', async () => {
+        // Arrange
+        const subject = container
+            .getAll<ICommandHandler>(InjectionTypes.CommandHandlers)
+            .find(x => x.constructor.name === `${DivideByZeroCommand.name}`);
+
+        // Act
+        subject.handle(channel, command, user, message, []);
+
+        // Assert
+        expect(expectedChatClient.say)
+            .toHaveBeenCalledTimes(1);
+        expect(expectedChatClient.say)
+            .toHaveBeenCalledWith(channel, expect.anything());
+        expect(expectedLogger.info)
+            .toHaveBeenCalledWith(expect
+                .stringMatching(`(?=.*\\b${command}\\b)(?=.*\\b${channel}\\b)(?=.*\\b${user.displayName}\\b)(?=.*\\b${message}\\b)`));
+    });
+});

bot/commands/aboutCommand.spec.ts

@@ -0,0 +1,61 @@
+// reflect-metadata should be imported
+// before any interface or other imports
+// also it should be imported only once
+// so that a singleton is created.
+import 'reflect-metadata';
+import { ChatClient, ChatUser } from '@twurple/chat';
+import { Container } from 'inversify';
+import winston from 'winston';
+import { mockChatClient, mockLogger } from '../../tests/common.mocks';
+import InjectionTypes from '../../dependency-management/types';
+import { ICommandHandler } from './iCommandHandler';
+import { AboutCommand } from './aboutCommand';
+
+describe('About Command Tests', () => {
+    const channel = 'TestChannel';
+    const command = 'TestCommand';
+    const user = <ChatUser>{ displayName: 'TestUser' };
+    const message = 'TestMessage';
+
+    const container: Container = new Container();
+    let expectedChatClient: ChatClient;
+    let expectedLogger: winston.Logger;
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        container.unbindAll();
+        container
+            .bind<ChatClient>(ChatClient)
+            .toConstantValue(mockChatClient);
+
+        container
+            .bind<winston.Logger>(InjectionTypes.Logger)
+            .toConstantValue(mockLogger);
+
+        container
+            .bind<ICommandHandler>(InjectionTypes.CommandHandlers)
+            .to(AboutCommand);
+
+        expectedChatClient = container
+            .get(ChatClient);
+
+        expectedLogger = container
+            .get<winston.Logger>(InjectionTypes.Logger);
+    });
+
+    it('should say something in chat about bot', () => {
+        // arrange
+        const subject = container
+            .getAll<ICommandHandler>(InjectionTypes.CommandHandlers)
+            .find(x => x.constructor.name === `${AboutCommand.name}`);
+
+        // act
+        subject.handle(channel, command, user, message);
+
+        // assert
+        expect(expectedChatClient.say).toHaveBeenCalledWith(channel, expect.anything());
+        expect(expectedLogger.info)
+            .toHaveBeenCalledWith(expect
+                .stringMatching(`(?=.*\\b${command}\\b)(?=.*\\b${channel}\\b)(?=.*\\b${user.displayName}\\b)(?=.*\\b${message}\\b)`));
+    });
+});

bot/commands/accountAgeCommand.spec.ts

@@ -0,0 +1,93 @@
+// reflect-metadata should be imported
+// before any interface or other imports
+// also it should be imported only once
+// so that a singleton is created.
+import 'reflect-metadata';
+import { ApiClient, HelixUser } from '@twurple/api';
+import { ChatClient, ChatUser } from '@twurple/chat';
+import { Container } from 'inversify';
+import winston from 'winston';
+import { mockChatClient, mockLogger } from '../../tests/common.mocks';
+import InjectionTypes from '../../dependency-management/types';
+import { ICommandHandler } from './iCommandHandler';
+import { AccountAgeCommand } from './accountAgeCommand';
+import Timespan, { getAgeReport } from '../utilities/timeSpan';
+
+describe('Account Age Command Tests', () => {
+    const channel = 'TestChannel';
+    const command = 'TestCommand';
+    const message = 'TestMessage';
+
+    const container: Container = new Container();
+    let expectedChatClient: ChatClient;
+    let expectedLogger: winston.Logger;
+    let mockApiClient: ApiClient;
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        container.unbindAll();
+        container
+            .bind<ChatClient>(ChatClient)
+            .toConstantValue(mockChatClient);
+
+        container
+            .bind<winston.Logger>(InjectionTypes.Logger)
+            .toConstantValue(mockLogger);
+
+        container
+            .bind<ICommandHandler>(InjectionTypes.CommandHandlers)
+            .to(AccountAgeCommand);
+
+        expectedChatClient = container
+            .get(ChatClient);
+
+        expectedLogger = container
+            .get<winston.Logger>(InjectionTypes.Logger);
+    });
+
+    describe('should report account age of target account', () => {
+        it.each([
+            [
+                <ChatUser>{ displayName: 'TestUser', userName: 'TestUser' },
+                [],
+                <HelixUser>{ displayName: 'TestUser', creationDate: new Date(2000, 0, 1) },
+            ], [
+                <ChatUser>{ displayName: 'TestUser', userName: 'TestUser' },
+                ['', 'UserName'],
+                <HelixUser>{ displayName: 'UserName', creationDate: new Date(2000, 0, 1) },
+            ],
+        ])(`user: '%s', arguments: '%s', reported user '%s'`, async (chatUser: ChatUser, args: string[], apiUser: HelixUser) => {
+            // Arrange
+            mockApiClient = <unknown>{
+                users: {
+                    getUserByName: jest.fn().mockResolvedValue(apiUser),
+                },
+            } as ApiClient;
+
+            container
+                .bind<ApiClient>(ApiClient)
+                .toConstantValue(mockApiClient);
+
+            const subject = container
+                .getAll<ICommandHandler>(InjectionTypes.CommandHandlers)
+                .find(x => x.constructor.name === AccountAgeCommand.name);
+
+            const age = getAgeReport(Timespan.fromNow(apiUser.creationDate));
+
+            // Act
+            await subject.handle(channel, command, chatUser, message, args);
+
+            // Assert
+            expect(mockApiClient.users.getUserByName)
+                .toHaveBeenCalledWith(args[1]
+                    ? args[1].toLocaleLowerCase().trim()
+                    : chatUser.userName);
+            expect(expectedChatClient.say)
+                .toHaveBeenCalledWith(channel, expect
+                    .stringMatching(`(?=.*\\b${apiUser.displayName}\\b)(?=.*\\b${age}\\b)`));
+            expect(expectedLogger.info)
+                .toHaveBeenCalledWith(expect
+                    .stringMatching(`(?=.*\\b${command}\\b)(?=.*\\b${channel}\\b)(?=.*\\b${chatUser.displayName}\\b)(?=.*\\b${message}\\b)`));
+        });
+    });
+});

bot/commands/brainCommand.spec.ts

@@ -0,0 +1,75 @@
+// reflect-metadata should be imported
+// before any interface or other imports
+// also it should be imported only once
+// so that a singleton is created.
+import 'reflect-metadata';
+import { ChatClient, ChatUser } from '@twurple/chat';
+import { Container } from 'inversify';
+import winston from 'winston';
+import { mockChatClient, mockLogger } from '../../tests/common.mocks';
+import InjectionTypes from '../../dependency-management/types';
+import { ICommandHandler } from './iCommandHandler';
+import BrainCommand from './brainCommand';
+
+describe('Brain Command Tests', () => {
+    const channel = 'TestChannel';
+    const command = 'TestCommand';
+    const message = 'TestMessage';
+
+    const container: Container = new Container();
+    let expectedChatClient: ChatClient;
+    let expectedLogger: winston.Logger;
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        container.unbindAll();
+        container
+            .bind<ChatClient>(ChatClient)
+            .toConstantValue(mockChatClient);
+
+        container
+            .bind<winston.Logger>(InjectionTypes.Logger)
+            .toConstantValue(mockLogger);
+
+        container
+            .bind<ICommandHandler>(InjectionTypes.CommandHandlers)
+            .to(BrainCommand);
+
+        expectedChatClient = container
+            .get(ChatClient);
+
+        expectedLogger = container
+            .get<winston.Logger>(InjectionTypes.Logger);
+    });
+
+    describe('should report brain about target', () => {
+        it.each([
+            [
+                <ChatUser>{ displayName: 'TestUser', userName: 'TestUser' },
+                [],
+            ], [
+                <ChatUser>{ displayName: 'TestUser', userName: 'TestUser' },
+                ['UserName'],
+            ],
+        ])(`user: '%s', target args: '%s'`, async (chatUser: ChatUser, args: string[]) => {
+            // Arrange
+            const subject = container
+                .getAll<ICommandHandler>(InjectionTypes.CommandHandlers)
+                .find(x => x.constructor.name === `${BrainCommand.name}`);
+
+            // Act
+            const user = args[0]
+                ? args[0].toLocaleLowerCase().trim()
+                : chatUser.displayName;
+            await subject.handle(channel, command, chatUser, message, args);
+
+            // Assert
+            expect(expectedChatClient.say)
+                .toHaveBeenCalledWith(channel, expect
+                    .stringMatching(`(?=.*(\\b${user}\\b))(?=.*(\\b[0-9]{1,3}[%\\b]{1}))`));
+            expect(expectedLogger.info)
+                .toHaveBeenCalledWith(expect
+                    .stringMatching(`(?=.*\\b${command}\\b)(?=.*\\b${channel}\\b)(?=.*\\b${chatUser.displayName}\\b)(?=.*\\b${message}\\b)`));
+        });
+    });
+});

bot/commands/brainCommand.ts

@@ -19,7 +19,6 @@ export default class BrainCommand implements ICommandHandler {
 
     constructor(
         @inject(ChatClient) private chatClient: ChatClient,
-        @inject(ApiClient) private apiClient: ApiClient,
         @inject(InjectionTypes.Logger) private logger: winston.Logger,
     ) {
     }