Roll command (#41)

* roll command

roll command

roll command

roll command

roll command

roll command

clean and fix

* fix

* test + sugggestions

* fix tests

Author: Razi91

src/commands/index.spec.ts

@@ -15,7 +15,7 @@ describe('index', () => {
       const memberMock = {
         hasPermission: Sinon.spy(),
       };
-      msg.guild.members.fetch.resolves(memberMock);
+      msg.guild.fetchMember.resolves(memberMock);
       msg.author.send.resolves();
       await handleCommand((msg as unknown) as Discord.Message);
       expect(msg.reply).to.have.been.calledOnceWith('Wysłałam Ci DM ze wszystkimi komendami! 🎉');

src/commands/index.ts

@@ -14,6 +14,7 @@ import odpowiedz from './odpowiedz';
 import prune from './prune';
 import quiz from './quiz';
 import regulamin from './regulamin';
+import roll from './roll';
 import server from './server';
 import spotify from './spotify';
 import xd from './xd';
@@ -36,6 +37,7 @@ const allCommands = {
   prune,
   quiz,
   regulamin,
+  roll,
   server,
   spotify,
   xd,

src/commands/prune.spec.ts

@@ -37,20 +37,25 @@ describe('prune', () => {
 
   it('should fetch messages and delete them', async () => {
     const msg = getMessageMock('msg');
+    const memberMock = {
+      hasPermission: Sinon.spy(),
+    };
     // tslint:disable-next-line: no-any
     const messagesCollectionMock = { clear: Sinon.spy() };
-    msg.channel.messages.fetch.resolves(messagesCollectionMock);
+    // msg.channel.messages.fetch.resolves(messagesCollectionMock);
+    msg.channel.fetchMessages.resolves(messagesCollectionMock);
+    msg.guild.fetchMember.resolves(memberMock);
 
     await expect(prune.execute((msg as unknown) as Discord.Message, ['2'])).to.be.fulfilled;
-    await expect(msg.channel.messages.fetch).to.have.been.calledOnceWithExactly({ limit: 2 });
+    await expect(msg.channel.fetchMessages).to.have.been.calledOnceWithExactly({ limit: 2 });
     await expect(messagesCollectionMock.clear).to.have.been.calledOnce;
   });
 
   it('should delete itself', async () => {
     const msg = getMessageMock('msg');
     // tslint:disable-next-line: no-any
     const messagesCollectionMock = { clear: Sinon.spy() } as any;
-    msg.channel.messages.fetch.resolves(messagesCollectionMock);
+    msg.channel.fetchMessages.resolves(messagesCollectionMock);
 
     await prune.execute((msg as unknown) as Discord.Message, ['2']);
 

src/commands/roll.spec.ts

@@ -0,0 +1,65 @@
+/* eslint no-implicit-dependencies: "off" */
+/* eslint no-magic-numbers: "off" */
+/* tslint:disable:no-implicit-dependencies no-magic-numbers */
+import { expect } from 'chai';
+import 'mocha';
+
+import { getMessageMock } from '../../test/mocks';
+import * as Discord from 'discord.js';
+
+import roll, { parseDice, rollDices, instruction } from './roll';
+
+describe('roll', () => {
+  describe('parser', () => {
+    it('parses valid simple roll', () => {
+      const res = parseDice('4d6');
+      expect(res.count).to.be.equal(4);
+      expect(res.dice).to.be.equal(6);
+    });
+    it('throws on invalid input', () => {
+      expect(() => parseDice('4ds6')).to.throw();
+    });
+    it('parses valid roll with modifier', () => {
+      const res = parseDice('4d6+5');
+      expect(res.count).to.be.equal(4);
+      expect(res.dice).to.be.equal(6);
+      expect(res.modifier).to.be.equal(5);
+    });
+    it('parses valid roll with negative modifier', () => {
+      const res = parseDice('4d6-3');
+      expect(res.count).to.be.equal(4);
+      expect(res.dice).to.be.equal(6);
+      expect(res.modifier).to.be.equal(-3);
+    });
+  });
+  describe('roll', () => {
+    it('allows valid response', () => {
+      const count = 4;
+      const dice = 6;
+      const modifier = 1;
+      const notation = `${count}d${dice}+${modifier}`;
+      const res = rollDices(notation);
+      expect(res.notation).to.be.equal(notation);
+      expect(res.value).to.be.lessThan(count * dice * modifier + 1);
+    });
+    it('does not allow invalid response', () => {
+      const count = 400;
+      const dice = 6;
+      const modifier = 1;
+      const notation = `${count}d${dice}+${modifier}`;
+      expect(() => rollDices(notation)).to.throw();
+    });
+  });
+  describe('handleCommand', () => {
+    it('should reply', async () => {
+      const msg = getMessageMock('msg');
+      await roll.execute((msg as unknown) as Discord.Message, ['4d6']);
+      await expect(msg.channel.send).to.have.been.calledOnce;
+    });
+    it('reply instruction on fail', async () => {
+      const msg = getMessageMock('msg');
+      await roll.execute((msg as unknown) as Discord.Message, ['3k5']);
+      await expect(msg.channel.send).to.have.been.calledOnceWith(instruction);
+    });
+  });
+});

src/commands/roll.ts

@@ -0,0 +1,55 @@
+import { Command } from '../types';
+
+const MAX_COUNT = 20;
+const MAX_DICE = 100;
+const REGEX = /([0-9]{1,4})d([0-9]{1,4})([+-][0-9]{1,10})?/;
+
+export function parseDice(arg: string) {
+  const res = arg.match(REGEX);
+  if (res == null) {
+    throw new Error('Invalid argument');
+  }
+  const [notation, count, dice, modifier] = res;
+  return {
+    notation,
+    count: parseInt(count, 10),
+    dice: parseInt(dice, 10),
+    modifier: parseInt(modifier ?? 0, 10),
+  };
+}
+
+export function rollDices(content: string) {
+  const parsed = parseDice(content);
+  if (parsed.count <= 0 || parsed.count > MAX_COUNT || parsed.dice <= 0 || parsed.dice > MAX_DICE) {
+    throw new Error('Invalid argument values');
+  }
+  const rolls = Array.from({ length: parsed.count })
+    .map(() => Math.random() * parsed.dice + 1)
+    .map(Math.floor);
+  return {
+    notation: parsed.notation,
+    value: rolls.reduce((acc, val) => acc + val, parsed.modifier),
+    rolls,
+  };
+}
+
+export const instruction =
+  'Wpisz `!roll [liczba kości]d[liczba ścian]`, aby rzucić kośćmi, np `!roll 2d6+1`';
+
+const roll: Command = {
+  name: 'roll',
+  description: 'Rzuca kośćmi.',
+  args: true,
+  execute(msg, args) {
+    try {
+      const result = rollDices(args[0]);
+      const rollsResult = `${result.rolls.join('+')}`;
+      const response = `:game_die: [${result.notation}] **${result.value}** = ${rollsResult}`;
+      return msg.channel.send(response);
+    } catch (error) {
+      return msg.channel.send(instruction);
+    }
+  },
+};
+
+export default roll;

test/mocks.ts

@@ -40,17 +40,13 @@ export const getMessageMock = (name: string, params: any = {}) => {
     ...params,
     channel: {
       send: Sinon.stub(),
-      messages: {
-        fetch: Sinon.stub(),
-      },
+      fetchMessages: Sinon.stub(),
       type: '',
       [Symbol.toStringTag]: () => 'MOCK CHANNEL',
       ...params.channel,
     },
     guild: {
-      members: {
-        fetch: Sinon.stub(),
-      },
+      fetchMember: Sinon.stub(),
       ...params.guild,
     },
     delete: Sinon.stub(),