@valkyriestudios/utils 4.0.0 → 5.0.0

package/test/src/function.test.js

@@ -1,83 +1,81 @@
 'use strict';
 
 import isFunction   from '../../src/function/is';
+import sleep        from '../../src/function/sleep';
 import noop         from '../../src/function/noop';
 import noopreturn   from '../../src/function/noopreturn';
 import noopresolve  from '../../src/function/noopresolve';
+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("Function - isFunction", () => {
     it ('not see a string as a function', () => {
-        expect(isFunction('foo')).toEqual(false);
-        expect(isFunction(new String('bar'))).toEqual(false);
+        let vals = fnStringValues();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a function', () => {
-        expect(isFunction(1)).toEqual(false);
-        expect(isFunction(NaN)).toEqual(false);
-        expect(isFunction(0.000001)).toEqual(false);
-        expect(isFunction(8e10)).toEqual(false);
-        expect(isFunction(Math.PI)).toEqual(false);
-        expect(isFunction(new Number(1.12345))).toEqual(false);
-        expect(isFunction(new Number(Number.EPSILON))).toEqual(false);
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a boolean as a function', () => {
-        expect(isFunction(true)).toEqual(false);
-        expect(isFunction(false)).toEqual(false);
-        expect(isFunction(Boolean(true))).toEqual(false);
-        expect(isFunction(Boolean(false))).toEqual(false);
-        expect(isFunction(Boolean('foo'))).toEqual(false);
-        expect(isFunction(new Boolean(false))).toEqual(false);
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a regex as a function', () => {
-        expect(isFunction(/abcdefg/i)).toEqual(false);
-        expect(isFunction(new RegExp('\\w+'))).toEqual(false);
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see an object as a function', () => {
-        expect(isFunction({bar:'foo'})).toEqual(false);
-        expect(isFunction(new Object())).toEqual(false);
-        expect(isFunction(Object.create(null))).toEqual(false);
-        expect(isFunction(Object.create([]))).toEqual(false);
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
-    it ('not see a null as a function', () => {
-        expect(isFunction(null)).toEqual(false);
+    it ('not see a nullable as a function', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see a date as a function', () => {
-        expect(isFunction(new Date())).toEqual(false);
-        expect(isFunction(Date.now())).toEqual(false);
-    });
-
-    it ('not see an undefined as a function', () => {
-        expect(isFunction(undefined)).toEqual(false);
+        let vals = fnDateValues();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('not see an array as a function', () => {
-        expect(isFunction([0, 1, 2])).toEqual(false);
-        expect(isFunction(new Array(1, 2, 3))).toEqual(false);
-        expect(isFunction(new Array(5))).toEqual(false);
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isFunction(el)).to.eql(false);
     });
 
     it ('see a function as a function', () => {
-        function testFunction () {}
-
-        const testArrowFunction = () => {};
-
-        expect(isFunction(testFunction)).toEqual(true);
-        expect(isFunction(testArrowFunction)).toEqual(true);
-    });
-
-    it ('not see formdata as a function', () => {
-        let fdata = new FormData();
-        expect(isFunction(fdata)).toEqual(false);
+        let vals = fnFunctionValues();
+        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 {
@@ -86,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;
@@ -95,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 {
@@ -121,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) {
@@ -130,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;
@@ -164,35 +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};
+        const fn_spy = spy(o, 'fn');
+        await o.fn(0);
+        expect(fn_spy).to.have.been.called;
+    });
+
+    it ('returns a promise', () => {
+        const rslt = sleep();
+        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).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

@@ -0,0 +1,187 @@
+'use strict';
+
+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)).to.eql(true);
+    });
+
+    it ('Should be a frozen object', () => {
+        expect(Object.isFrozen(Is)).to.eql(true);
+    });
+
+//  Is.Array
+
+    it ('[fn-array] Should have an Array function', () => {
+        expect(isFunction(Is.Array)).to.eql(true);
+    });
+
+    it ('[fn-array] Should link to isArray', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-notemptyarray] Should link to isNotEmptyArray', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-boolean] Should link to isBoolean', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-date] Should link to isDate', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-function] Should link to isFunction', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-number] Should link to isNumber', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-numberbetween] Should link to isNumberBetween', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-regexp] Should link to isRegExp', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-object] Should link to isObject', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-notemptyobject] Should link to isNotEmptyObject', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-string] Should link to isString', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-stringbetween] Should link to isStringBetween', () => {
+        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)).to.eql(true);
+    });
+
+    it ('[fn-notemptystring] Should link to isNotEmptyString', () => {
+        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);
+    });
+
+});