@valkyriestudios/utils 4.0.0 → 5.0.0

package/test/src/array.test.js

@@ -1,102 +1,99 @@
 'use strict';
 
-import isArray  from '../../src/array/is';
-import dedupe   from '../../src/array/dedupe';
+import isArray          from '../../src/array/is';
+import isNotEmptyArray  from '../../src/array/isNotEmpty';
+import dedupe           from '../../src/array/dedupe';
+import {
+    fnNumericValues,
+    fnBooleanValues,
+    fnRegexValues,
+    fnStringValues,
+    fnObjectValues,
+    fnDateValues,
+    fnArrayValues,
+    fnFunctionValues,
+    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', () => {
-        expect(isArray('foo')).toEqual(false);
-        expect(isArray(new String('bar'))).toEqual(false);
+        let vals = fnStringValues();
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a numeric value as an array', () => {
-        expect(isArray(1)).toEqual(false);
-        expect(isArray(NaN)).toEqual(false);
-        expect(isArray(0.000001)).toEqual(false);
-        expect(isArray(8e10)).toEqual(false);
-        expect(isArray(Math.PI)).toEqual(false);
-        expect(isArray(new Number(1.12345))).toEqual(false);
-        expect(isArray(new Number(Number.EPSILON))).toEqual(false);
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a boolean as an array', () => {
-        expect(isArray(true)).toEqual(false);
-        expect(isArray(false)).toEqual(false);
-        expect(isArray(Boolean(true))).toEqual(false);
-        expect(isArray(Boolean(false))).toEqual(false);
-        expect(isArray(Boolean('foo'))).toEqual(false);
-        expect(isArray(new Boolean(false))).toEqual(false);
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a regex as an array', () => {
-        expect(isArray(/abcdefg/i)).toEqual(false);
-        expect(isArray(new RegExp('\\w+'))).toEqual(false);
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see an object as an array', () => {
-        expect(isArray({bar:'foo'})).toEqual(false);
-        expect(isArray(new Object())).toEqual(false);
-        expect(isArray(Object.create(null))).toEqual(false);
-        expect(isArray(Object.create([]))).toEqual(false);
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
-    it ('not see a null as an array', () => {
-        expect(isArray(null)).toEqual(false);
+    it ('not see a nullable as an array', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('not see a date as an array', () => {
-        expect(isArray(new Date())).toEqual(false);
-        expect(isArray(Date.now())).toEqual(false);
-    });
-
-    it ('not see an undefined as an array', () => {
-        expect(isArray(undefined)).toEqual(false);
+        let vals = fnDateValues();
+        for (let el of vals) expect(isArray(el)).to.eql(false);
     });
 
     it ('see an array as an array', () => {
-        expect(isArray([0, 1, 2])).toEqual(true);
-        expect(isArray(new Array(1, 2, 3))).toEqual(true);
-        expect(isArray(new Array(5))).toEqual(true);
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isArray(el)).to.eql(true);
     });
 
     it ('not see a function as an array', () => {
-        function testFunction () {}
-
-        const testArrowFunction = () => {};
-
-        expect(isArray(testFunction)).toEqual(false);
-        expect(isArray(testArrowFunction)).toEqual(false);
-    });
-
-    it ('not see formdata as an array', () => {
-        let fdata = new FormData();
-        expect(isArray(fdata)).toEqual(false);
+        let vals = fnFunctionValues();
+        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', () => {
@@ -121,6 +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)).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)).to.eql(false);
+    });
+
+    it ('not see a boolean as a non empty array', () => {
+        let vals = fnBooleanValues();
+        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)).to.eql(false);
+    });
+
+    it ('not see an object as a non empty array', () => {
+        let vals = fnObjectValues();
+        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)).to.eql(false);
+    });
+
+    it ('not see a date as a non empty array', () => {
+        let vals = fnDateValues();
+        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)).to.eql(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())).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)).to.eql(false);
     });
 });

package/test/src/boolean.test.js

@@ -1,74 +1,70 @@
 'use strict';
 
 import isBoolean from '../../src/boolean/is';
+import {
+    fnNumericValues,
+    fnBooleanValues,
+    fnRegexValues,
+    fnStringValues,
+    fnObjectValues,
+    fnDateValues,
+    fnArrayValues,
+    fnFunctionValues,
+    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', () => {
-        expect(isBoolean('foo')).toEqual(false);
-        expect(isBoolean(new String('bar'))).toEqual(false);
+        let vals = fnStringValues();
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a boolean', () => {
-        expect(isBoolean(1)).toEqual(false);
-        expect(isBoolean(NaN)).toEqual(false);
-        expect(isBoolean(0.000001)).toEqual(false);
-        expect(isBoolean(8e10)).toEqual(false);
-        expect(isBoolean(Math.PI)).toEqual(false);
-        expect(isBoolean(new Number(1.12345))).toEqual(false);
-        expect(isBoolean(new Number(Number.EPSILON))).toEqual(false);
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('see a boolean as a boolean', () => {
-        expect(isBoolean(true)).toEqual(true);
-        expect(isBoolean(false)).toEqual(true);
-        expect(isBoolean(Boolean(true))).toEqual(true);
-        expect(isBoolean(Boolean(false))).toEqual(true);
-        expect(isBoolean(Boolean('foo'))).toEqual(true);
-        expect(isBoolean(new Boolean(false))).toEqual(true);
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isBoolean(el)).to.eql(true);
     });
 
     it ('not see a regex as a boolean', () => {
-        expect(isBoolean(/abcdefg/i)).toEqual(false);
-        expect(isBoolean(new RegExp('\\w+'))).toEqual(false);
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see an object as a boolean', () => {
-        expect(isBoolean({bar:'foo'})).toEqual(false);
-        expect(isBoolean(new Object())).toEqual(false);
-        expect(isBoolean(Object.create(null))).toEqual(false);
-        expect(isBoolean(Object.create([]))).toEqual(false);
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
-    it ('not see a null as a boolean', () => {
-        expect(isBoolean(null)).toEqual(false);
+    it ('not see a nullable as a boolean', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see a date as a boolean', () => {
-        expect(isBoolean(new Date())).toEqual(false);
-        expect(isBoolean(Date.now())).toEqual(false);
-    });
-
-    it ('not see an undefined as a boolean', () => {
-        expect(isBoolean(undefined)).toEqual(false);
+        let vals = fnDateValues();
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see an array as a boolean', () => {
-        expect(isBoolean([0, 1, 2])).toEqual(false);
-        expect(isBoolean(new Array(1, 2, 3))).toEqual(false);
-        expect(isBoolean(new Array(5))).toEqual(false);
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isBoolean(el)).to.eql(false);
     });
 
     it ('not see a function as a boolean', () => {
-        function testFunction () {}
-
-        const testArrowFunction = () => {};
-
-        expect(isBoolean(testFunction)).toEqual(false);
-        expect(isBoolean(testArrowFunction)).toEqual(false);
-    });
-
-    it ('not see formdata as a boolean', () => {
-        let fdata = new FormData();
-        expect(isBoolean(fdata)).toEqual(false);
+        let vals = fnFunctionValues();
+        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

@@ -1,74 +1,70 @@
 'use strict';
 
 import isDate from '../../src/date/is';
+import {
+    fnNumericValues,
+    fnBooleanValues,
+    fnRegexValues,
+    fnStringValues,
+    fnObjectValues,
+    fnDateValues,
+    fnArrayValues,
+    fnFunctionValues,
+    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', () => {
-        expect(isDate('foo')).toEqual(false);
-        expect(isDate(new String('bar'))).toEqual(false);
+        let vals = fnStringValues();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a date', () => {
-        expect(isDate(1)).toEqual(false);
-        expect(isDate(NaN)).toEqual(false);
-        expect(isDate(0.000001)).toEqual(false);
-        expect(isDate(8e10)).toEqual(false);
-        expect(isDate(Math.PI)).toEqual(false);
-        expect(isDate(new Number(1.12345))).toEqual(false);
-        expect(isDate(new Number(Number.EPSILON))).toEqual(false);
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a boolean as a date', () => {
-        expect(isDate(true)).toEqual(false);
-        expect(isDate(false)).toEqual(false);
-        expect(isDate(Boolean(true))).toEqual(false);
-        expect(isDate(Boolean(false))).toEqual(false);
-        expect(isDate(Boolean('foo'))).toEqual(false);
-        expect(isDate(new Boolean(false))).toEqual(false);
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a regex as a date', () => {
-        expect(isDate(/abcdefg/i)).toEqual(false);
-        expect(isDate(new RegExp('\\w+'))).toEqual(false);
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see an object as a date', () => {
-        expect(isDate({bar:'foo'})).toEqual(false);
-        expect(isDate(new Object())).toEqual(false);
-        expect(isDate(Object.create(null))).toEqual(false);
-        expect(isDate(Object.create([]))).toEqual(false);
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
-    it ('not see a null as a date', () => {
-        expect(isDate(null)).toEqual(false);
+    it ('not see a nullable as a date', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('see a date as a date', () => {
-        expect(isDate(new Date())).toEqual(true);
-        expect(isDate(Date.now())).toEqual(false);
-    });
-
-    it ('not see an undefined as a date', () => {
-        expect(isDate(undefined)).toEqual(false);
+        let vals = fnDateValues();
+        for (let el of vals) expect(isDate(el)).to.eql(true);
     });
 
     it ('not see an array as a date', () => {
-        expect(isDate([0, 1, 2])).toEqual(false);
-        expect(isDate(new Array(1, 2, 3))).toEqual(false);
-        expect(isDate(new Array(5))).toEqual(false);
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 
     it ('not see a function as a date', () => {
-        function testFunction () {}
-
-        const testArrowFunction = () => {};
-
-        expect(isDate(testFunction)).toEqual(false);
-        expect(isDate(testArrowFunction)).toEqual(false);
-    });
-
-    it ('not see formdata as a date', () => {
-        let fdata = new FormData();
-        expect(isDate(fdata)).toEqual(false);
+        let vals = fnFunctionValues();
+        for (let el of vals) expect(isDate(el)).to.eql(false);
     });
 });