Merge pull request #113 from osu-cascades/rc-v2.1.0

Author: ctsstc

.nvmrc

@@ -1 +1 @@
-node
+v13.7

__tests__/commands/__snapshots__/help.test.ts.snap

@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Help Command Execute DMs commands with prefix and descriptions it still looks the same 1`] = `
+"I am here to help! Well...mostly just make you chuckle at this point, let's be honest.
+
+Here is a list of the commands that we've got right now:
+\`\`\`
+!one       → I am number one.
+!two       → Two is not just a number.
+!blueFish  → Not a red fish.
+\`\`\`"
+`;

__tests__/commands/help.test.ts

@@ -0,0 +1,110 @@
+import Help from '../../src/commands/help';
+import Commands from '../../src/library/commands';
+import { message as mockMessage, MockedMessage } from '../mocks/discord';
+
+// TODO: These should be in a factory/mock
+const oneCommand = {
+  name: 'one',
+  description: 'I am number one.',
+  execute: jest.fn()
+};
+
+const twoCommand = {
+  name: 'two',
+  description: 'Two is not just a number.',
+  execute: jest.fn()
+};
+
+const blueFishCommand = {
+  name: 'blueFish',
+  description: 'Not a red fish.',
+  execute: jest.fn()
+};
+
+const commands = new Commands({
+  one: oneCommand,
+  two: twoCommand,
+  blueFish: blueFishCommand
+});
+
+let sendMock: MockedMessage;
+let authorSend: MockedMessage;
+beforeEach(() => {
+  sendMock = jest.fn();
+  mockMessage.reply = sendMock;
+  authorSend = jest.fn();
+  // @ts-ignore
+  mockMessage.author = {
+    send: authorSend
+  };
+});
+
+describe('Help Command', () => {
+  describe('Execute', () => {
+    beforeEach(() => {
+      Help.execute([], mockMessage, { commands });
+    });
+
+    test('Lets you know to check your DMs', () => {
+      expect(sendMock).lastCalledWith('sliding into your DMs...');
+    });
+
+    describe('DMs commands with prefix and descriptions', () => {
+      let message: string;
+      beforeEach(() => {
+        message = authorSend.mock.calls[0][0];
+      });
+
+      test('Snarky', () => {
+        const snark = "I am here to help! Well...mostly just make you chuckle " +
+          "at this point, let's be honest.";
+        expect(message).toContain(snark);
+      });
+
+      test('Command pretext header', () => {
+        const pretext = "Here is a list of the commands that we've got right now:";
+        expect(message).toContain(pretext);
+      });
+
+      test('Code block start', () => {
+        expect(message).toContain('```\n');
+      });
+
+      test('Code block end', () => {
+        const lines = message.split('\n');
+        const lastLine = lines[lines.length - 1];
+        expect(lastLine).toEqual('```');
+      });
+
+      test('it still looks the same', () => {
+        expect(message).toMatchSnapshot();
+      });
+
+      describe('Commands', () => {
+        test('one command', () => {
+          expect(message).toContain('!one');
+        });
+
+        test('one description', () => {
+          expect(message).toContain(oneCommand.description);
+        });
+
+        test('two command', () => {
+          expect(message).toContain('!two');
+        });
+
+        test('two description', () => {
+          expect(message).toContain(twoCommand.description);
+        });
+
+        test('blueFish command', () => {
+          expect(message).toContain('!blueFish');
+        });
+
+        test('BlueFish description', () => {
+          expect(message).toContain(blueFishCommand.description);
+        });
+      });
+    });
+  });
+});

__tests__/commands/search.test.ts

@@ -43,10 +43,24 @@ describe('Search Command', () => {
     await Search.execute(['dingusy'], mockMessage);
     expect(sendMock).lastCalledWith(results.items[0].link);
   });
-  test('Malformed Response', async () => {
-    const mockedData = Promise.resolve({ data: {} });
-    axiosMock.get.mockResolvedValueOnce(mockedData);
-    await Search.execute(['NOPE'], mockMessage);
-    expect(sendMock).lastCalledWith("I'm Sorry Dave, I'm afraid I can't do that...");
+  describe('Malformed Response', () => {
+    let consoleErrorMock: jest.SpyInstance<void, any>;
+    beforeEach(async () => {
+      const mockedData = Promise.resolve({ data: {} });
+      axiosMock.get.mockResolvedValueOnce(mockedData);
+      consoleErrorMock = jest.spyOn(console, 'error')
+        .mockImplementation(() => undefined); // Prevent it from spewing into the test results
+      await Search.execute(['NOPE'], mockMessage);
+    });
+    afterEach(() => {
+      consoleErrorMock.mockRestore();
+    });
+    test('Responds with error message', async () => {
+      expect(sendMock).lastCalledWith("I'm Sorry Dave, I'm afraid I can't do that...");
+    });
+    test('Console logs an error', () => {
+      const errorMessage = "Malformed Google Search Response: {}";
+      expect(consoleErrorMock).lastCalledWith(errorMessage);
+    });
   });
 });

__tests__/library/commandLoader.test.ts

@@ -1,10 +1,10 @@
 import glob from 'glob';
 import CommandLoader, { ICommandClasses } from '../../src/library/commandLoader';
-import { COMMANDS_PATH_GLOB } from './../../src/library/commands';
 
 describe('CommandLoader', () => {
   let commandClasses: ICommandClasses;
-  const files = glob.sync(COMMANDS_PATH_GLOB);
+  const commandsPathGlob = './src/commands/*.ts';
+  const files = glob.sync(commandsPathGlob);
 
   beforeEach(() => {
     commandClasses = CommandLoader.getCommandClasses(files);
@@ -16,6 +16,7 @@ describe('CommandLoader', () => {
     });
   });
 
+  // More of an integration test against real commands
   describe('Class names match their file names', () => {
     test('they match their key name', () => {
       for (let commandName of Object.keys(commandClasses)) {

__tests__/library/commands.test.ts

@@ -1,16 +1,43 @@
+import { ICommandClasses } from '../../src/library/commandLoader';
 import Commands from '../../src/library/commands';
+import ICommand from '../../src/library/iCommand';
 
-// TODO: I feel like this class is too basic to test,
-//  and ultimately a wrapper for other classes that have been tested
-//  Might just remove it some day
 describe('Commands', () => {
-  const commands = new Commands();
-  test('Has a command', () => {
-    expect(Object.keys(commands.all).length).toBeGreaterThan(0);
-    expect(commands.names.length).toBeGreaterThan(0);
+  let mockHelloCommand: ICommand;
+  let mockYetAnotherCommand: ICommand;
+  let mockCommands: ICommandClasses;
+  let commands: Commands;
+
+  beforeEach(() => {
+    // TODO: these should probably go into a factory/mock
+    mockHelloCommand = {
+      name: 'Hello',
+      description: 'Hello World',
+      execute: jest.fn()
+    };
+    mockYetAnotherCommand = {
+      name: 'YAC',
+      description: 'Yet Another Command!',
+      execute: jest.fn()
+    };
+    mockCommands = {
+      hello: mockHelloCommand,
+      yac: mockYetAnotherCommand
+    };
+    commands = new Commands(mockCommands);
+  });
+
+  test('.names returns command names', () => {
+    const commandNames = ['hello', 'yac'];
+    expect(commands.names).toEqual(commandNames);
   });
+
   test('Can fetch a command', () => {
-    const first = commands.names[0];
-    expect(commands.get(first)).not.toBeUndefined();
+    const helloCommand = commands.get('hello');
+    expect(helloCommand).toBe(mockHelloCommand);
+  });
+
+  test('Finds the longest name', () => {
+    expect(commands.longestNameLength()).toEqual(5);
   });
 });