typed-utilities/build/__tests__/Array.test.js

Strongly typed general purpose utilities

"use strict";

var _fastDeepEqual = _interopRequireDefault(require("fast-deep-equal"));

var _ = require("..");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

describe(`Array`, () => {
  describe(`containEqualItems`, () => {
    test(`numbers`, () => {
      const t1 = [1, 2, 3];
      const t2 = [2, 3, 1];
      const t3 = [1, 2, 4, 3];
      expect((0, _.containEqualItems)(t1, t2)).toEqual(true);
      expect((0, _.containEqualItems)(t1, t3)).toEqual(false);
      expect((0, _.containEqualItems)(t3, t1)).toEqual(false);

      const equalMod4 = (a, b) => a % 4 === b % 4;

      expect((0, _.containEqualItems)(t1, t2, equalMod4)).toEqual(true);
      expect((0, _.containEqualItems)(t1, t2, equalMod4)).toEqual(true);
      expect((0, _.containEqualItems)(t1, t3, equalMod4)).toEqual(false);
    });
    test(`objects`, () => {
      const t1 = [{
        key1: `value1`
      }, {
        key2: `value2`
      }];
      const t2 = [{
        key2: `value2`
      }, {
        key1: `value1`
      }];
      const t3 = [{
        key1: `value3`
      }, {
        key2: `value4`
      }];
      expect((0, _.containEqualItems)(t1, t2)).toEqual(false);
      expect((0, _.containEqualItems)(t1, t2, _fastDeepEqual.default)).toEqual(true);
      expect((0, _.containEqualItems)(t1, t3, _fastDeepEqual.default)).toEqual(false);
      expect((0, _.containEqualItems)(t3, t1, _fastDeepEqual.default)).toEqual(false);
      const t4 = [{
        p: 1,
        q: 2
      }, {
        p: 1,
        q: 3
      }];
      const t5 = [{
        p: 6,
        q: 18
      }, {
        p: 100,
        q: 200
      }];
      const t6 = [{
        p: 6,
        q: 200
      }, {
        p: 100,
        q: 18
      }];

      const equalRatio = (a, b) => a.p * b.q === a.q * b.p;

      expect((0, _.containEqualItems)(t4, t5, equalRatio)).toEqual(true);
      expect((0, _.containEqualItems)(t4, t6, equalRatio)).toEqual(false);
      expect((0, _.containEqualItems)(t5, t6, equalRatio)).toEqual(false);
    });
  });
  describe(`deduplicate`, () => {
    test(`numbers`, () => {
      const t = [1, 3, 1, 1, 3, 2];
      expect((0, _.deduplicate)(t)).toEqual([1, 3, 2]);
      expect((0, _.deduplicate)(t, (a, b) => a % 2 === b % 2)).toEqual([1, 2]);
    });
    test(`objects`, () => {
      const t1 = [{
        key1: `value1`
      }, {
        key1: `value2`
      }, {
        key2: `value1`
      }, {
        key1: `value1`
      }, {
        key2: `value2`
      }, {
        key1: `value1`
      }];
      expect((0, _.deduplicate)(t1)).toEqual(t1);
      expect((0, _.deduplicate)(t1, _fastDeepEqual.default)).toEqual([{
        key1: `value1`
      }, {
        key1: `value2`
      }, {
        key2: `value1`
      }, {
        key2: `value2`
      }]);
      const t2 = [{
        v: 0
      }, {
        v: 1
      }, {
        v: 0
      }, {
        v: 1
      }];
      expect((0, _.deduplicate)(t2)).toEqual(t2);
      expect((0, _.deduplicate)(t2, _fastDeepEqual.default)).toEqual([{
        v: 0
      }, {
        v: 1
      }]);
      expect((0, _.deduplicate)(t2, (a, b) => a.v === b.v)).toEqual([{
        v: 0
      }, {
        v: 1
      }]);
      const t3 = [{
        p: 1,
        q: 2
      }, {
        p: 0.5,
        q: 1
      }, {
        p: 2,
        q: 1
      }, {
        p: 2,
        q: 4
      }, {
        p: 12,
        q: 6
      }];
      expect((0, _.deduplicate)(t3)).toEqual(t3);
      expect((0, _.deduplicate)(t3, _fastDeepEqual.default)).toEqual(t3);
      expect((0, _.deduplicate)(t3, (a, b) => a.p * b.q === a.q * b.p)).toEqual([{
        p: 1,
        q: 2
      }, {
        p: 2,
        q: 1
      }]);
      expect((0, _.deduplicate)(t3, (a, b) => a.q === b.q || a.p === b.p)).toEqual([{
        p: 1,
        q: 2
      }, {
        p: 0.5,
        q: 1
      }, {
        p: 2,
        q: 4
      }, {
        p: 12,
        q: 6
      }]);
    });
  });
  describe(`intersection`, () => {
    test(`numbers`, () => {
      const t1 = [1, 3, 1, 2, 1];
      const t2 = [2, 1, 1, 1, 2];
      const t3 = [2];
      expect((0, _.intersection)([t1, t2])).toEqual([2, 1]);
      expect((0, _.intersection)([t1, t3])).toEqual([2]);
      expect((0, _.intersection)([t1, t2, t3])).toEqual([2]);
    });
    test(`objects`, () => {
      const t1 = [{
        v: 1
      }, {
        v: 3
      }, {
        v: 1
      }, {
        v: 2
      }, {
        v: 1
      }, {
        u: 3
      }];
      const t2 = [{
        v: 2
      }, {
        v: 1
      }, {
        v: 1
      }, {
        v: 1
      }, {
        u: 3
      }];
      const t3 = [{
        v: 2
      }, {
        u: 4
      }];
      expect((0, _.intersection)([t1, t2])).toEqual([]);
      expect((0, _.intersection)([t1, t2], _fastDeepEqual.default)).toEqual([{
        v: 2
      }, {
        v: 1
      }, {
        u: 3
      }]);
      expect((0, _.intersection)([t1, t3], _fastDeepEqual.default)).toEqual([{
        v: 2
      }]);
      expect((0, _.intersection)([t1, t2, t3], _fastDeepEqual.default)).toEqual([{
        v: 2
      }]);
    });
    test(`exactlyNone`, () => {
      expect((0, _.exactlyNone)([])).toEqual(null);
      expect(() => (0, _.exactlyNone)([1])).toThrow();
      expect(() => (0, _.exactlyNone)([1, 2])).toThrow();
    });
    test(`exactlyOne`, () => {
      expect(() => (0, _.exactlyOne)([])).toThrow();
      expect((0, _.exactlyOne)([1])).toEqual(1);
      expect(() => (0, _.exactlyOne)([1, 2])).toThrow();
    });
    test(`exactlyOneOrNone`, () => {
      expect((0, _.exactlyOneOrNone)([])).toEqual(null);
      expect((0, _.exactlyOneOrNone)([1])).toEqual(1);
      expect(() => (0, _.exactlyOneOrNone)([1, 2])).toThrow();
    });
  });
});
//# sourceMappingURL=Array.test.js.map