@valkyriestudios/utils 4.2.0 → 5.0.0

package/test/src/array.test.js

@@ -12,85 +12,88 @@ import {
     fnDateValues,
     fnArrayValues,
     fnFunctionValues,
-    fnFormDataValues,
     fnNullables,
 } from '../constants';
 
+const chai = require('chai');
+const spies = require('chai-spies');
+chai.use(spies);
+
+const expect = chai.expect;
+const assert = chai.assert;
+const should = chai.should();
+const spy = chai.spy;
+
 describe("Array - isArray", () => {
     it ('not see a string as an array', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a numeric value as an array', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a boolean as an array', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a regex as an array', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see an object as an array', () => {
         let vals = fnObjectValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a nullable as an array', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a date as an array', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('see an array as an array', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isArray(el)).toEqual(true);
+        for (let el of vals) expect(isArray(el)).to.eql(true);
     });
 
     it ('not see a function as an array', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
-    });
-
-    it ('not see formdata as an array', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isArray(el)).toEqual(false);
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 });
 
 describe("Array - dedupe", () => {
     it ('correctly remove duplicate bool flags from an array', () => {
-        expect(dedupe([true, false, false, false, true])).toEqual([true, false]);
+        expect(dedupe([true, false, false, false, true])).to.eql([true, false]);
     });
 
     it ('correctly remove duplicate numeric values from an array', () => {
-        expect(dedupe([0, 1, 1, 2, 99, 100, 99, 2, 3, 3, 4])).toEqual([0, 1, 2, 99, 100, 3, 4]);
+        expect(dedupe([0, 1, 1, 2, 99, 100, 99, 2, 3, 3, 4])).to.eql([0, 1, 2, 99, 100, 3, 4]);
     });
 
     it ('correctly remove duplicate strings from an array', () => {
-        expect(dedupe(['foo', 'bar', 'foo', 'foo', 'bar', 'test', 'test'])).toEqual(['foo', 'bar', 'test']);
+        expect(dedupe(['foo', 'bar', 'foo', 'foo', 'bar', 'test', 'test'])).to.eql(['foo', 'bar', 'test']);
     });
 
     it ('correctly remove duplicates in a mixed primitive array', () => {
         expect(dedupe(['foo', null, 1, 2, NaN, 'bar', undefined, 'bar', true, true, false, NaN, 1, 2, false, null, undefined ]))
-        .toEqual(['foo', null, 1, 2, NaN, 'bar', undefined, true, false]);
+        .to.eql(['foo', null, 1, 2, NaN, 'bar', undefined, true, false]);
     });
 
     it ('correctly remove duplicate arrays from an array', () => {
         let test_a = [0, 1, 2, 3, 'hello', 'world', 4, 5];
         let test_b = [0, 1, [ 'foo', 'bar'], 2, 3, [['a'], ['b']]];
 
-        expect(dedupe([test_a, test_b, test_b, test_a])).toEqual([test_a, test_b]);
+        expect(dedupe([test_a, test_b, test_b, test_a])).to.eql([test_a, test_b]);
     });
 
     it ('correctly remove duplicate objects from an array', () => {
@@ -115,67 +118,62 @@ describe("Array - dedupe", () => {
             test_b,
             test_a,
             test_b,
-        ])).toEqual([test_a, test_b]);
+        ])).to.eql([test_a, test_b]);
     });
 });
 
 describe("Array - isNotEmptyArray", () => {
     it ('not see a string as a non empty array', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a non empty array', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 
     it ('not see a boolean as a non empty array', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 
     it ('not see a regex as a non empty array', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 
     it ('not see an object as a non empty array', () => {
         let vals = fnObjectValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 
     it ('not see a nullable as a non empty array', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 
     it ('not see a date as a non empty array', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 
     it ('see a non empty array as a non empty array', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(true);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(true);
 
-        expect(isNotEmptyArray([false])).toEqual(true);
-        expect(isNotEmptyArray([null])).toEqual(true);
-        expect(isNotEmptyArray([undefined])).toEqual(true);
+        expect(isNotEmptyArray([false])).to.eql(true);
+        expect(isNotEmptyArray([null])).to.eql(true);
+        expect(isNotEmptyArray([undefined])).to.eql(true);
     });
 
     it ('not see an empty array as a non empty array', () => {
-        expect(isNotEmptyArray(new Array())).toEqual(false);
-        expect(isNotEmptyArray([])).toEqual(false);
+        expect(isNotEmptyArray(new Array())).to.eql(false);
+        expect(isNotEmptyArray([])).to.eql(false);
     });
 
     it ('not see a function as a non empty array', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
-    });
-
-    it ('not see formdata as a non empty array', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isNotEmptyArray(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyArray(el)).to.eql(false);
     });
 });

package/test/src/boolean.test.js

@@ -10,58 +10,61 @@ import {
     fnDateValues,
     fnArrayValues,
     fnFunctionValues,
-    fnFormDataValues,
     fnNullables,
 } from '../constants';
 
+const chai = require('chai');
+const spies = require('chai-spies');
+chai.use(spies);
+
+const expect = chai.expect;
+const assert = chai.assert;
+const should = chai.should();
+const spy = chai.spy;
+
 describe("Boolean - isBoolean", () => {
     it ('not see a string as a boolean', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a boolean', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('see a boolean as a boolean', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(true);
+        for (let el of vals) expect(isBoolean(el)).to.eql(true);
     });
 
     it ('not see a regex as a boolean', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see an object as a boolean', () => {
         let vals = fnObjectValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see a nullable as a boolean', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see a date as a boolean', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see an array as a boolean', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see a function as a boolean', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
-    });
-
-    it ('not see formdata as a boolean', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isBoolean(el)).toEqual(false);
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 });

package/test/src/caching.test.js

@@ -3,6 +3,15 @@
 import memoize  from '../../src/caching/memoize';
 import fnv1A    from '../../src/hash/fnv1A';
 
+const chai = require('chai');
+const spies = require('chai-spies');
+chai.use(spies);
+
+const expect = chai.expect;
+const assert = chai.assert;
+const should = chai.should();
+const spy = chai.spy;
+
 describe("Caching - memoize", () => {
     let rslt_uncached, rslt_cached;
 
@@ -46,6 +55,6 @@ describe("Caching - memoize", () => {
     });
 
     it ('should cache', () => {
-        expect(rslt_cached < rslt_uncached).toBe(true);
+        expect(rslt_cached < rslt_uncached).to.eql(true);
     });
 });

package/test/src/date.test.js

@@ -10,58 +10,61 @@ import {
     fnDateValues,
     fnArrayValues,
     fnFunctionValues,
-    fnFormDataValues,
     fnNullables,
 } from '../constants';
 
+const chai = require('chai');
+const spies = require('chai-spies');
+chai.use(spies);
+
+const expect = chai.expect;
+const assert = chai.assert;
+const should = chai.should();
+const spy = chai.spy;
+
 describe("Date - isDate", () => {
     it ('not see a string as a date', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a date', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a boolean as a date', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a regex as a date', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see an object as a date', () => {
         let vals = fnObjectValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a nullable as a date', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('see a date as a date', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isDate(el)).toEqual(true);
+        for (let el of vals) expect(isDate(el)).to.eql(true);
     });
 
     it ('not see an array as a date', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a function as a date', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
-    });
-
-    it ('not see formdata as a date', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isDate(el)).toEqual(false);
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 });