@valkyriestudios/utils 4.2.0 → 5.0.0

package/test/src/function.test.js

@@ -14,64 +14,68 @@ 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("Function - isFunction", () => {
     it ('not see a string as a function', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a function', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a boolean as a function', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a regex as a function', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see an object as a function', () => {
         let vals = fnObjectValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a nullable as a function', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a date as a function', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see an array as a function', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('see a function as a function', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(true);
-    });
-
-    it ('not see formdata as a function', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isFunction(el)).toEqual(false);
+        for (let el of vals) expect(isFunction(el)).to.eql(true);
     });
 });
 
 describe("Function - noop", () => {
     let obj, rslt, thrown, var_a;
+    let spy_fn = false;
 
     beforeEach(() => {
         try {
@@ -80,8 +84,7 @@ describe("Function - noop", () => {
             var_a   = 42;
             thrown  = false;
 
-            spyOn(obj, 'fn');
-
+            spy_fn = spy(obj, 'fn');
             rslt = obj.fn(var_a);
         } catch (err) {
             thrown = true;
@@ -89,24 +92,25 @@ describe("Function - noop", () => {
     });
 
     it ('execute the function when called', () => {
-        expect(obj.fn).toHaveBeenCalled();
+        expect(spy_fn).to.have.been.called;
     });
 
     it ('return nothing', () => {
-        expect(rslt).toBeUndefined();
+        expect(rslt).to.eql(undefined);
     });
 
     it ('not affect parameters', () => {
-        expect(var_a).toBe(42);
+        expect(var_a).to.eql(42);
     });
 
     it ('not throw an error', () => {
-        expect(thrown).toBe(false);
+        expect(thrown).to.eql(false);
     });
 });
 
 describe("Function - noopreturn", () => {
     let obj, rslt, thrown, var_a;
+    let spy_fn = false;
 
     beforeEach(() => {
         try {
@@ -115,7 +119,7 @@ describe("Function - noopreturn", () => {
             var_a   = 42;
             thrown  = false;
 
-            spyOn(obj, 'fn').and.callThrough();
+            spy_fn = spy(obj, 'fn');
             rslt = obj.fn(var_a);
             rslt = obj.fn(obj.fn(var_a));
         } catch (err) {
@@ -124,33 +128,34 @@ describe("Function - noopreturn", () => {
     });
 
     it ('execute the function when called', () => {
-        expect(obj.fn).toHaveBeenCalled();
+        expect(spy_fn).to.have.been.called;
     });
 
     it ('return passed variable', () => {
-        expect(rslt).toBe(42);
+        expect(rslt).to.eql(42);
     });
 
     it ('not affect parameters', () => {
-        expect(var_a).toBe(42);
+        expect(var_a).to.eql(42);
     });
 
     it ('not throw an error', () => {
-        expect(thrown).toBe(false);
+        expect(thrown).to.eql(false);
     });
 });
 
 describe("Function - noopresolve", () => {
     let obj, rslt, thrown, var_a;
+    let spy_fn = false;
 
     beforeEach(() => {
         try {
-            obj     = { fn : noopresolve };
+            obj     = {fn : noopresolve};
             rslt    = undefined;
             var_a   = 42;
             thrown  = false;
 
-            spyOn(obj, 'fn').and.callThrough();
+            spy_fn = spy(obj, 'fn');
             rslt = obj.fn(var_a);
         } catch (err) {
             thrown = true;
@@ -158,56 +163,53 @@ describe("Function - noopresolve", () => {
     });
 
     it ('execute the function when called', () => {
-        expect(obj.fn).toHaveBeenCalled();
+        expect(spy_fn).to.have.been.called;
     });
 
     it ('returns a promise', (next) => {
-        expect(rslt instanceof Promise).toBe(true);
+        expect(rslt instanceof Promise).to.eql(true);
         next();
     });
 
-    it ('returns a resolved promise', (next) => {
-        rslt.then(
-            next,
-            () => next(new Error('Promise should have resolved, instead it rejected'))
-        ).catch(
-            () => next(new Error('Promise should have resolved, instead it threw an error'))
-        );
+    it ('returns a resolved promise', async () => {
+        let is_resolved = false;
+        await rslt.then(() => is_resolved = true, () => {}).catch(() => {});
+        expect(is_resolved).to.eql(true);
     });
 
     it ('resolving the promise returns passed variable', (next) => {
         rslt.then((value) => {
-            expect(value).toBe(42);
+            expect(value).to.eql(42);
             next();
         });
     });
 
     it ('not affect parameters', () => {
-        expect(var_a).toBe(42);
+        expect(var_a).to.eql(42);
     });
 
     it ('not throw an error', () => {
-        expect(thrown).toBe(false);
+        expect(thrown).to.eql(false);
     });
 });
 
 describe("Function - sleep", () => {
     it ('execute the function when called', async () => {
-        const o = { fn: sleep };
-        spyOn(o, 'fn').and.callThrough();
+        const o = {fn: sleep};
+        const fn_spy = spy(o, 'fn');
         await o.fn(0);
-        expect(o.fn).toHaveBeenCalled();
+        expect(fn_spy).to.have.been.called;
     });
 
     it ('returns a promise', () => {
         const rslt = sleep();
-        expect(rslt instanceof Promise).toBe(true);
+        expect(rslt instanceof Promise).to.eql(true);
     });
 
     it ('resolves after the provided time', async () => {
         const timer_start = new Date();
         await sleep(200);
         const timer_end = new Date() - timer_start;
-        expect(timer_end >= 200).toBe(true);
+        expect(timer_end >= 200).to.eql(true);
     });
 });

package/test/src/hash.test.js

@@ -3,20 +3,29 @@
 import guid     from '../../src/hash/guid';
 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("Hash - Guid", () => {
     it ('output a string value', () => {
         let g = guid();
-        expect(g).toEqual(jasmine.any(String));
+        assert.typeOf(g, 'string');
     });
 
     it ('have exactly 36 characters', () => {
         let g = guid();
-        expect(g.length).toBe(36);
+        expect(g.length).to.eql(36);
     });
 
     it ('match the rfc4122 spec', () => {
         let g = guid();
-        expect(/^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$/g.test(g)).toBe(true);
+        expect(/^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$/g.test(g)).to.eql(true);
     });
 
     it ('be unique (50.000 benchmark)', () => {
@@ -28,7 +37,7 @@ describe("Hash - Guid", () => {
             cursor++;
         }
 
-        expect(Object.keys(cache).length).toBe(cursor);
+        expect(Object.keys(cache).length).to.eql(cursor);
     });
 });
 
@@ -63,39 +72,39 @@ describe("Hash - FNV1A", () => {
         const e_2 = fnv1A(new RegExp('abcdefg', 'i'));
         const e_3 = fnv1A(new RegExp('abcdefg', 'ig'));
         const e_4 = fnv1A(new RegExp('abcdefghij', 'i'));
-        expect(a_1).toEqual(a_2);
-        expect(b_1).toEqual(b_2);
-        expect(c_1).toEqual(c_2);
-        expect(d_1).toEqual(d_2);
-        expect(d_1 === d_3).toEqual(false);
-        expect(e_1).toEqual(e_2);
-        expect(e_1 === e_3).toEqual(false);
-        expect(e_1 === e_4).toEqual(false);
+        expect(a_1).to.eql(a_2);
+        expect(b_1).to.eql(b_2);
+        expect(c_1).to.eql(c_2);
+        expect(d_1).to.eql(d_2);
+        expect(d_1 === d_3).to.eql(false);
+        expect(e_1).to.eql(e_2);
+        expect(e_1 === e_3).to.eql(false);
+        expect(e_1 === e_4).to.eql(false);
     });
 
     it ('should throw a type error when passed an unhashable value', () => {
-        expect(function () { fnv1A(new Function()) }).toThrowError(TypeError);
+        expect(function () { fnv1A(new Function()) }).to.throw(TypeError);
     });
 
     //  Based on some tests available at : http://isthe.com/chongo/src/fnv/test_fnv.c
     it ('should output values that equal the official spec (32 bit)', () => {
-        expect(fnv1A("")).toEqual(0x811c9dc5);
-        expect(fnv1A("a")).toEqual(0xe40c292c);
-        expect(fnv1A("b")).toEqual(0xe70c2de5);
-        expect(fnv1A("c")).toEqual(0xe60c2c52);
-        expect(fnv1A("d")).toEqual(0xe10c2473);
-        expect(fnv1A("e")).toEqual(0xe00c22e0);
-        expect(fnv1A("f")).toEqual(0xe30c2799);
-        expect(fnv1A("fo")).toEqual(0x6222e842);
-        expect(fnv1A("foo")).toEqual(0xa9f37ed7);
-        expect(fnv1A("foob")).toEqual(0x3f5076ef);
-        expect(fnv1A("fooba")).toEqual(0x39aaa18a);
-        expect(fnv1A("foobar")).toEqual(0xbf9cf968);
-        expect(fnv1A("64.81.78.84")).toEqual(0xa55b89ed);
-        expect(fnv1A("feedfacedaffdeed")).toEqual(0xe83641e1);
-        expect(fnv1A("http://www.fourmilab.ch/gravitation/orbits/")).toEqual(0x29b50b38);
-        expect(fnv1A("EFCDAB8967452301")).toEqual(0x7fcb2275);
-        expect(fnv1A("2^21701-1")).toEqual(0xc0ed2114);
+        expect(fnv1A("")).to.eql(0x811c9dc5);
+        expect(fnv1A("a")).to.eql(0xe40c292c);
+        expect(fnv1A("b")).to.eql(0xe70c2de5);
+        expect(fnv1A("c")).to.eql(0xe60c2c52);
+        expect(fnv1A("d")).to.eql(0xe10c2473);
+        expect(fnv1A("e")).to.eql(0xe00c22e0);
+        expect(fnv1A("f")).to.eql(0xe30c2799);
+        expect(fnv1A("fo")).to.eql(0x6222e842);
+        expect(fnv1A("foo")).to.eql(0xa9f37ed7);
+        expect(fnv1A("foob")).to.eql(0x3f5076ef);
+        expect(fnv1A("fooba")).to.eql(0x39aaa18a);
+        expect(fnv1A("foobar")).to.eql(0xbf9cf968);
+        expect(fnv1A("64.81.78.84")).to.eql(0xa55b89ed);
+        expect(fnv1A("feedfacedaffdeed")).to.eql(0xe83641e1);
+        expect(fnv1A("http://www.fourmilab.ch/gravitation/orbits/")).to.eql(0x29b50b38);
+        expect(fnv1A("EFCDAB8967452301")).to.eql(0x7fcb2275);
+        expect(fnv1A("2^21701-1")).to.eql(0xc0ed2114);
     });
 
 });

package/test/src/is.test.js

@@ -4,187 +4,184 @@ import Is           from '../../src/is';
 import isObject     from '../../src/object/is';
 import isFunction   from '../../src/function/is';
 
+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("Is", () => {
 
     it ('Should be an object', () => {
-        expect(isObject(Is)).toEqual(true);
+        expect(isObject(Is)).to.eql(true);
     });
 
     it ('Should be a frozen object', () => {
-        expect(Object.isFrozen(Is)).toEqual(true);
+        expect(Object.isFrozen(Is)).to.eql(true);
     });
 
 //  Is.Array
 
     it ('[fn-array] Should have an Array function', () => {
-        expect(isFunction(Is.Array)).toEqual(true);
+        expect(isFunction(Is.Array)).to.eql(true);
     });
 
     it ('[fn-array] Should link to isArray', () => {
-        expect(Is.Array([])).toEqual(true);
-        expect(Is.Array({})).toEqual(false);
+        expect(Is.Array([])).to.eql(true);
+        expect(Is.Array({})).to.eql(false);
     });
 
 //  Is.NotEmptyArray
 
     it ('[fn-notemptyarray] Should have a NotEmptyArray function', () => {
-        expect(isFunction(Is.Array)).toEqual(true);
+        expect(isFunction(Is.Array)).to.eql(true);
     });
 
     it ('[fn-notemptyarray] Should link to isNotEmptyArray', () => {
-        expect(Is.NotEmptyArray([1, 2, 3])).toEqual(true);
-        expect(Is.NotEmptyArray([])).toEqual(false);
-        expect(Is.NotEmptyArray({})).toEqual(false);
+        expect(Is.NotEmptyArray([1, 2, 3])).to.eql(true);
+        expect(Is.NotEmptyArray([])).to.eql(false);
+        expect(Is.NotEmptyArray({})).to.eql(false);
     });
 
 //  Is.Boolean
 
     it ('[fn-boolean] Should have a Boolean function', () => {
-        expect(isFunction(Is.Boolean)).toEqual(true);
+        expect(isFunction(Is.Boolean)).to.eql(true);
     });
 
     it ('[fn-boolean] Should link to isBoolean', () => {
-        expect(Is.Boolean([])).toEqual(false);
-        expect(Is.Boolean(false)).toEqual(true);
-        expect(Is.Boolean(true)).toEqual(true);
+        expect(Is.Boolean([])).to.eql(false);
+        expect(Is.Boolean(false)).to.eql(true);
+        expect(Is.Boolean(true)).to.eql(true);
     });
 
 //  Is.Date
 
     it ('[fn-date] Should have a Date function', () => {
-        expect(isFunction(Is.Date)).toEqual(true);
+        expect(isFunction(Is.Date)).to.eql(true);
     });
 
     it ('[fn-date] Should link to isDate', () => {
-        expect(Is.Date([1, 2, 3])).toEqual(false);
-        expect(Is.Date('2021-01-01')).toEqual(false);
-        expect(Is.Date(new Date())).toEqual(true);
-    });
-
-//  Is.FormData
-
-    it ('[fn-formdata] Should have a FormData function', () => {
-        expect(isFunction(Is.FormData)).toEqual(true);
-    });
-
-    it ('[fn-formdata] Should link to isFormData', () => {
-        expect(Is.FormData([1, 2, 3])).toEqual(false);
-        expect(Is.FormData('2021-01-01')).toEqual(false);
-        expect(Is.FormData(new FormData())).toEqual(true);
+        expect(Is.Date([1, 2, 3])).to.eql(false);
+        expect(Is.Date('2021-01-01')).to.eql(false);
+        expect(Is.Date(new Date())).to.eql(true);
     });
 
 //  Is.Function
 
     it ('[fn-function] Should have a Function function', () => {
-        expect(isFunction(Is.Function)).toEqual(true);
+        expect(isFunction(Is.Function)).to.eql(true);
     });
 
     it ('[fn-function] Should link to isFunction', () => {
-        expect(Is.Function([1, 2, 3])).toEqual(false);
-        expect(Is.Function('2021-01-01')).toEqual(false);
-        expect(Is.Function(() => {})).toEqual(true);
+        expect(Is.Function([1, 2, 3])).to.eql(false);
+        expect(Is.Function('2021-01-01')).to.eql(false);
+        expect(Is.Function(() => {})).to.eql(true);
     });
 
 //  Is.Number
 
     it ('[fn-number] Should have a Number function', () => {
-        expect(isFunction(Is.Number)).toEqual(true);
+        expect(isFunction(Is.Number)).to.eql(true);
     });
 
     it ('[fn-number] Should link to isNumber', () => {
-        expect(Is.Number([1, 2, 3])).toEqual(false);
-        expect(Is.Number('2021-01-01')).toEqual(false);
-        expect(Is.Number(1)).toEqual(true);
+        expect(Is.Number([1, 2, 3])).to.eql(false);
+        expect(Is.Number('2021-01-01')).to.eql(false);
+        expect(Is.Number(1)).to.eql(true);
     });
 
 //  Is.NumberBetween
 
     it ('[fn-numberbetween] Should have a NumberBetween function', () => {
-        expect(isFunction(Is.NumberBetween)).toEqual(true);
+        expect(isFunction(Is.NumberBetween)).to.eql(true);
     });
 
     it ('[fn-numberbetween] Should link to isNumberBetween', () => {
-        expect(Is.NumberBetween(1, 0, 2)).toEqual(true);
-        expect(Is.NumberBetween(10, 10, 11)).toEqual(true);
-        expect(Is.NumberBetween(50, 10, 30)).toEqual(false);
-        expect(Is.NumberBetween('a', 2, 6)).toEqual(false);
-        expect(Is.NumberBetween({})).toEqual(false);
+        expect(Is.NumberBetween(1, 0, 2)).to.eql(true);
+        expect(Is.NumberBetween(10, 10, 11)).to.eql(true);
+        expect(Is.NumberBetween(50, 10, 30)).to.eql(false);
+        expect(Is.NumberBetween('a', 2, 6)).to.eql(false);
+        expect(Is.NumberBetween({})).to.eql(false);
     });
 
 //  Is.RegExp
 
     it ('[fn-regexp] Should have a RegExp function', () => {
-        expect(isFunction(Is.RegExp)).toEqual(true);
+        expect(isFunction(Is.RegExp)).to.eql(true);
     });
 
     it ('[fn-regexp] Should link to isRegExp', () => {
-        expect(Is.RegExp([1, 2, 3])).toEqual(false);
-        expect(Is.RegExp('2021-01-01')).toEqual(false);
-        expect(Is.RegExp(/hi/g)).toEqual(true);
+        expect(Is.RegExp([1, 2, 3])).to.eql(false);
+        expect(Is.RegExp('2021-01-01')).to.eql(false);
+        expect(Is.RegExp(/hi/g)).to.eql(true);
     });
 
 //  Is.Object
 
     it ('[fn-object] Should have an Object function', () => {
-        expect(isFunction(Is.Object)).toEqual(true);
+        expect(isFunction(Is.Object)).to.eql(true);
     });
 
     it ('[fn-object] Should link to isObject', () => {
-        expect(Is.Object([1, 2, 3])).toEqual(false);
-        expect(Is.Object('2021-01-01')).toEqual(false);
-        expect(Is.Object({a:1})).toEqual(true);
+        expect(Is.Object([1, 2, 3])).to.eql(false);
+        expect(Is.Object('2021-01-01')).to.eql(false);
+        expect(Is.Object({a:1})).to.eql(true);
     });
 
 //  Is.NotEmptyObject
 
     it ('[fn-notemptyobject] Should have an NotEmptyObject function', () => {
-        expect(isFunction(Is.NotEmptyObject)).toEqual(true);
+        expect(isFunction(Is.NotEmptyObject)).to.eql(true);
     });
 
     it ('[fn-notemptyobject] Should link to isNotEmptyObject', () => {
-        expect(Is.NotEmptyObject([1, 2, 3])).toEqual(false);
-        expect(Is.NotEmptyObject('2021-01-01')).toEqual(false);
-        expect(Is.NotEmptyObject({a:1})).toEqual(true);
-        expect(Is.NotEmptyObject({})).toEqual(false);
+        expect(Is.NotEmptyObject([1, 2, 3])).to.eql(false);
+        expect(Is.NotEmptyObject('2021-01-01')).to.eql(false);
+        expect(Is.NotEmptyObject({a:1})).to.eql(true);
+        expect(Is.NotEmptyObject({})).to.eql(false);
     });
 
 //  Is.String
 
     it ('[fn-string] Should have a String function', () => {
-        expect(isFunction(Is.String)).toEqual(true);
+        expect(isFunction(Is.String)).to.eql(true);
     });
 
     it ('[fn-string] Should link to isString', () => {
-        expect(Is.String([1, 2, 3])).toEqual(false);
-        expect(Is.String('2021-01-01')).toEqual(true);
-        expect(Is.String({a:1})).toEqual(false);
+        expect(Is.String([1, 2, 3])).to.eql(false);
+        expect(Is.String('2021-01-01')).to.eql(true);
+        expect(Is.String({a:1})).to.eql(false);
     });
 
 //  Is.StringBetween
 
     it ('[fn-stringbetween] Should have a StringBetween function', () => {
-        expect(isFunction(Is.StringBetween)).toEqual(true);
+        expect(isFunction(Is.StringBetween)).to.eql(true);
     });
 
     it ('[fn-stringbetween] Should link to isStringBetween', () => {
-        expect(Is.StringBetween([1, 2, 3])).toEqual(false);
-        expect(Is.StringBetween('2021-01-01', 0, 10)).toEqual(true);
-        expect(Is.StringBetween('a', 2, 6)).toEqual(false);
-        expect(Is.StringBetween({})).toEqual(false);
+        expect(Is.StringBetween([1, 2, 3])).to.eql(false);
+        expect(Is.StringBetween('2021-01-01', 0, 10)).to.eql(true);
+        expect(Is.StringBetween('a', 2, 6)).to.eql(false);
+        expect(Is.StringBetween({})).to.eql(false);
     });
 
 //  Is.NotEmptyString
 
     it ('[fn-notemptystring] Should have an NotEmptyString function', () => {
-        expect(isFunction(Is.NotEmptyString)).toEqual(true);
+        expect(isFunction(Is.NotEmptyString)).to.eql(true);
     });
 
     it ('[fn-notemptystring] Should link to isNotEmptyString', () => {
-        expect(Is.NotEmptyString([1, 2, 3])).toEqual(false);
-        expect(Is.NotEmptyString('2021-01-01')).toEqual(true);
-        expect(Is.NotEmptyString('')).toEqual(false);
-        expect(Is.NotEmptyString({a:1})).toEqual(false);
-        expect(Is.NotEmptyString({})).toEqual(false);
+        expect(Is.NotEmptyString([1, 2, 3])).to.eql(false);
+        expect(Is.NotEmptyString('2021-01-01')).to.eql(true);
+        expect(Is.NotEmptyString('')).to.eql(false);
+        expect(Is.NotEmptyString({a:1})).to.eql(false);
+        expect(Is.NotEmptyString({})).to.eql(false);
     });
 
 });