Merge branch 'master' into edge

__tests__/helpers.js

@@ -0,0 +1,18 @@
+function expectOperator(test, operator, number) {
+  switch (operator) {
+    case '=':
+      return expect(test).toEqual(number);
+    case '<':
+      return expect(test).toBeLessThan(number);
+    case '<=':
+      return expect(test).toBeLessThanOrEqual(number);
+    case '>':
+      return expect(test).toBeGreaterThan(number);
+    case '>=':
+      return expect(test).toBeGreaterThanOrEqual(number);
+    case '!=':
+      return expect(test).not.toEqual(number);
+  }
+}
+
+module.exports = { expectOperator };

__tests__/serverjs/cards.test.js

@@ -79,6 +79,7 @@ const _RankleMasterofFixtures = {
     Modern: true,
     Standard: true,
     Pauper: false,
+    Pioneer: true,
   },
   parsed_cost: ['b', 'b', '2'],
   colors: ['B'],
@@ -105,6 +106,21 @@ test('cardFromId returns a well-formed card object', () => {
   });
 });
 
+test('cardFromId returns only selected fields', () => {
+  expect.assertions(1);
+  const _id = _RankleMasterofFixtures._id;
+  const expected = {
+    _id: '93c2c11d-dfc3-4ba9-8c0f-a98114090396',
+    name: 'Rankle, Master of Pranks',
+    colors: ['B'],
+  };
+  var promise = carddb.initializeCardDb(fixturesPath, true);
+  return promise.then(function() {
+    const result = carddb.cardFromId(_id, '_id name colors');
+    expect(result).toEqual(expected);
+  });
+});
+
 test('cardFromId returns a placeholder card object when given a nonexistent ID', () => {
   expect.assertions(1);
   const _id = 'not real';

__tests__/serverjs/draftutil.test.js

@@ -1,81 +1,199 @@
-var sinon = require('sinon');
-
+const carddb = require('../../serverjs/cards');
+const fixturesPath = 'fixtures';
+const cubefixture = require('../../fixtures/examplecube');
+const sinon = require('sinon');
 const methods = require('../../serverjs/draftutil');
-
 let CardRating = require('../../models/cardrating');
 
-beforeEach(() => {
-  sinon.stub(CardRating, 'find');
-});
+import Filter from '../../src/util/Filter';
+import { expectOperator } from '../helpers';
 
-afterEach(() => {
-  CardRating.find.restore();
-});
+describe('getDraftBots', () => {
+  it('can get the correct number of draft bots', () => {
+    const params = {
+      seats: 5,
+    };
+    const result = methods.getDraftBots(params);
+    expect(result.length).toBe(params.seats - 1);
+  });
 
-test('it can get the correct number of draft bots', () => {
-  const params = {
-    seats: 5,
-  };
-  const result = methods.getDraftBots(params);
-  expect(result.length).toBe(params.seats - 1);
-});
+  it('can get bots with the correct properties', () => {
+    const allColors = ['W', 'U', 'B', 'R', 'G'];
+    const params = {
+      seats: 2,
+    };
+    const result = methods.getDraftBots(params);
 
-test('it can get bots with the correct properties', () => {
-  const allColors = ['W', 'U', 'B', 'R', 'G'];
-  const params = {
-    seats: 2,
-  };
-  const result = methods.getDraftBots(params);
-
-  expect(result[0].length).toBe(2);
-  expect(allColors.includes(result[0][0])).toBe(true);
-  expect(allColors.includes(result[0][1])).toBe(true);
-  expect(result[0][0] === result[0][1]).toBe(false);
+    expect(result[0].length).toBe(2);
+    expect(allColors.includes(result[0][0])).toBe(true);
+    expect(allColors.includes(result[0][1])).toBe(true);
+    expect(result[0][0] === result[0][1]).toBe(false);
+  });
 });
 
-test('it returns the index of the first instance of a tag from a list of cards', () => {
-  const cards = [
-    {},
-    {},
-    {
-      tags: ['test'],
-    },
-    {
-      tags: ['test'],
-    },
-  ];
-  const tag = 'TEST';
-  const result = methods.indexOfTag(cards, tag);
-
-  expect(result).toBe(2);
-});
+describe('getDraftFormat', () => {
+  let exampleCube;
 
-test('it returns -1 if a tag is not found in a list of cards', () => {
-  const cards = [{}, {}];
-  const tag = 'TEST';
-  const result = methods.indexOfTag(cards, tag);
+  it('returns the default format if params are < 0', () => {
+    let params = {
+      id: -1,
+      seats: 4,
+      packs: 3,
+      cards: 2,
+    };
+    const format = methods.getDraftFormat(params, exampleCube);
+    let expected_format = [
+      ['*', '*'], // pack 1 (* is any card)
+      ['*', '*'], // pack 2
+      ['*', '*'], // pack 3
+    ];
+    expected_format.custom = false;
+    expected_format.multiples = false;
 
-  expect(result).toBe(-1);
-});
+    expect(format).toEqual(expected_format);
+    expect(format.custom).toBe(false);
+    expect(format.multiples).toBe(false);
+  });
+
+  describe('returns a custom format if params are > 0', () => {
+    let params;
+    beforeAll(() => {
+      params = { id: 0, seats: 8 }; // packs and cards determined by custom format
+      exampleCube = {};
+      exampleCube.draft_formats = [];
+      exampleCube.draft_formats[0] = {}; // mock
+    });
 
-test('getCardRatings returns a mapping of card names to values', () => {
-  var dummyModel = {
-    value: 1,
-    picks: 1,
-    name: 'Giant Growth',
-  };
-  var expected = {};
-  expected[dummyModel.name] = dummyModel.value;
-  CardRating.find.yields(null, [dummyModel]);
-  var callback = sinon.stub();
-  methods.getCardRatings([], CardRating, callback);
-  sinon.assert.calledWith(callback, expected);
+    let expectedFilters = function(...args) {
+      let expectedFormat = [];
+      args.forEach((filterText) => {
+        if (filterText !== null) {
+          let tokens = [];
+          Filter.tokenizeInput(filterText, tokens);
+          filterText = Filter.parseTokens(tokens);
+        }
+        expectedFormat.push([filterText]);
+      });
+      return expectedFormat;
+    };
+
+    describe.each([
+      [
+        'example filters - 1 pack, 1 card',
+        '[["rarity:Mythic,tag:New,identity>1"]]', // filter JSON
+        false, // multiples
+        [[expectedFilters('rarity:Mythic', 'tag:New', 'identity>1')]],
+      ],
+      [
+        'example filters - 1 pack, 2 cards, allow multiples',
+        '[["rarity:Mythic,tag:New,identity>1", "tag:mytag"]]', // filter JSON
+        true, // multiples
+        [[expectedFilters('rarity:Mythic', 'tag:New', 'identity>1'), expectedFilters('tag:mytag')]],
+      ],
+      [
+        'backwards compatible tags',
+        '[["mytag,*,*"]]', // filter JSON
+        false, // multiples
+        [[expectedFilters('tag:mytag', null, null)]],
+      ],
+      [
+        'mixed filters and tags with multiple packs with different card counts',
+        '[["rarity:Mythic,mytag"],["*"],["rarity:mythic,rarity:common","*"]]', // filter JSON
+        false, // multiples
+        [
+          [expectedFilters('rarity:Mythic', 'tag:mytag')], // pack 1
+          [[[null]]], // pack 2
+          [expectedFilters('rarity:Mythic', 'rarity:common'), [[null]]], // pack 3
+        ],
+      ],
+    ])('%s', (name, packsFormat, multiples, expected) => {
+      test(`returns expected format`, () => {
+        exampleCube.draft_formats[params.id].packs = packsFormat;
+        exampleCube.draft_formats[params.id].multiples = multiples;
+        // NOTE: Because format array als incudes properties (which we aren't testing in this test)
+        // we need to convert to json to compare safely.
+        // See https://github.com/facebook/jest/issues/8475
+        let formatJSON = JSON.stringify(methods.getDraftFormat(params, exampleCube));
+        let expectedJSON = JSON.stringify(expected);
+        expect(formatJSON).toEqual(expectedJSON);
+      });
+
+      test(`returned has correct multiples value`, () => {
+        exampleCube.draft_formats[params.id].packs = packsFormat;
+        exampleCube.draft_formats[params.id].multiples = multiples;
+        expect(methods.getDraftFormat(params, exampleCube).multiples).toEqual(multiples);
+      });
+
+      test(`returned format is marked as custom`, () => {
+        exampleCube.draft_formats[params.id].packs = packsFormat;
+        exampleCube.draft_formats[params.id].multiples = multiples;
+        expect(methods.getDraftFormat(params, exampleCube).custom).toEqual(true);
+      });
+    });
+  });
 });
 
-test('getCardRatings returns an empty dict when there are no ratings present ', () => {
-  var expected = {};
-  CardRating.find.yields(null, []);
-  var callback = sinon.stub();
-  methods.getCardRatings([], CardRating, callback);
-  sinon.assert.calledWith(callback, expected);
+describe('createDraft', () => {
+  let format, cards, bots, seats;
+  beforeAll(() => {
+    format = [];
+    cards = [];
+    bots = [];
+    seats = 8;
+  });
+
+  it('returns an error if no cards supplied', () => {
+    cards = [];
+    bots = ['fakebot'];
+    expect(() => {
+      methods.createDraft(format, cards, bots, seats);
+    }).toThrow(/no cards/);
+  });
+
+  it('returns an error if no bots supplied', () => {
+    cards = ['mockcard'];
+    bots = [];
+    expect(() => {
+      methods.createDraft(format, cards, bots, seats);
+    }).toThrow(/no bots/);
+  });
+
+  it('returns an error if seats < 2', () => {
+    cards = ['mockcards'];
+    bots = ['mockbot'];
+    expect(() => {
+      methods.createDraft(format, cards, bots, 1);
+    }).toThrow(/invalid seats/);
+    expect(() => {
+      methods.createDraft(format, cards, bots, null);
+    }).toThrow(/invalid seats/);
+    expect(() => {
+      methods.createDraft(format, cards, bots, -1);
+    }).toThrow(/invalid seats/);
+  });
+
+  it('sets the intitial state of the draft', () => {
+    let exampleCube = JSON.parse(JSON.stringify(cubefixture.exampleCube));
+    let promise = carddb.initializeCardDb(fixturesPath, true).then(() => {
+      exampleCube.cards.forEach(function(card, index) {
+        card.details = carddb.cardFromId(card.cardID);
+      });
+    });
+    return promise.then(() => {
+      cards = exampleCube.cards;
+      bots = ['mockbot'];
+      format = methods.getDraftFormat({ id: -1, packs: 1, cards: 15, seats: seats }, exampleCube);
+      let draft = methods.createDraft(format, cards, bots, 8);
+      expect(draft.pickNumber).toEqual(1);
+      expect(draft.packNumber).toEqual(1);
+      expect(draft).toHaveProperty('packs');
+      expect(draft).toHaveProperty('packs');
+      expect(draft).toHaveProperty('bots');
+      // CoreMongooseArray causing trouble, so we check length and use stringify
+      expect(draft.bots.length).toEqual(1);
+      let initial_stateJSON = JSON.stringify(draft.initial_state);
+      let packsJSON = JSON.stringify(draft.packs);
+      expect(initial_stateJSON).toEqual(packsJSON);
+    });
+  });
 });