@valkyriestudios/utils 5.1.0 → 5.2.0

package/test/src/equal.test.js

@@ -1,392 +0,0 @@
-'use strict';
-
-import equal    from '../../src/equal';
-import isDate   from '../../src/date/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("Equal", () => {
-//
-//  Primitive : Undefined
-//
-
-    it ('primitive - undefined : correctly flag equal', () => {
-        const a = undefined;
-        const b = undefined;
-        expect(equal(a, b)).to.eql(true);
-    });
-
-    it ('primitive - undefined : correctly flag inconsistency', () => {
-        const a = undefined;
-        const b = null;
-        const c = 'foo';
-        const d = false;
-        const e = 0;
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(a, c)).to.eql(false);
-        expect(equal(a, d)).to.eql(false);
-        expect(equal(a, e)).to.eql(false);
-    });
-
-//
-//  Primitive : Null
-//
-
-    it ('primitive - null : correctly flag equal', () => {
-        const a = null;
-        const b = null;
-        expect(equal(a, b)).to.eql(true);
-    });
-
-    it ('primitive - null : correctly flag inconsistency', () => {
-        const a = null;
-        const b = undefined;
-        const c = 'foo';
-        const d = false;
-        const e = 0;
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(a, c)).to.eql(false);
-        expect(equal(a, d)).to.eql(false);
-        expect(equal(a, e)).to.eql(false);
-    });
-
-//
-//  Primitive : String
-//
-
-    it ('primitive - string : correctly flag equal', () => {
-        const a = 'hello';
-        const b = 'hello';
-        expect(equal(a, b)).to.eql(true);
-    });
-
-    it ('primitive - string : correctly flag inconsistency', () => {
-        const a = 'foo';
-        const b = 'bar';
-        const c = 'foo ';
-        const d = undefined;
-        const e = false;
-        const f = new String('foo');
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(a, c)).to.eql(false);
-        expect(equal(a, d)).to.eql(false);
-        expect(equal(a, e)).to.eql(false);
-        expect(equal(a, f)).to.eql(false);
-    });
-
-//
-//  Primitive : Boolean
-//
-
-    it ('primitive - boolean : correctly flag equal', () => {
-        const a = false;
-        const b = false;
-        const c = true;
-        const d = true;
-        const e = new Boolean(false);
-        const f = new Boolean(false);
-        expect(equal(a, b)).to.eql(true);
-        expect(equal(c, d)).to.eql(true);
-        expect(equal(e, f)).to.eql(false);
-    });
-
-    it ('primitive - boolean : correctly flag inconsistency', () => {
-        const a = false;
-        const b = true;
-        const c = 1;
-        const d = 0;
-        const e = new Boolean(false);
-        const f = new Boolean(true);
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(a, c)).to.eql(false);
-        expect(equal(b, d)).to.eql(false);
-        expect(equal(a, e)).to.eql(false);
-        expect(equal(b, f)).to.eql(false);
-    });
-
-//
-//  Primitive : Boolean
-//
-
-    it ('primitive - number : correctly flag equal', () => {
-        const a = 512;
-        const b = 512;
-        const c = 512.00000000000;
-        const d = NaN;
-        const e = NaN;
-        expect(equal(a, b)).to.eql(true);
-        expect(equal(a, c)).to.eql(true);
-        expect(equal(d, e)).to.eql(true);
-    });
-
-    it ('primitive - number : correctly flag inconsistency', () => {
-        const a = 512;
-        const b = 256;
-        const c = NaN;
-        const d = '512';
-        const e = undefined;
-        const f = null;
-        const g = new Number(512);
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(a, c)).to.eql(false);
-        expect(equal(a, d)).to.eql(false);
-        expect(equal(c, e)).to.eql(false);
-        expect(equal(c, f)).to.eql(false);
-        expect(equal(a, g)).to.eql(false);
-    });
-
-//
-//  Date
-//
-
-    it ('complex - Date : correctly flag equal', () => {
-        const a = new Date(2018, 8, 10);
-        const b = new Date(2018, 8, 10);
-        const c = new Date('2018-09-10 00:00');
-        expect(equal(a, b)).to.eql(true);
-        expect(equal(a, c)).to.eql(true);
-    });
-
-    it ('complex - Date : correctly flag inconsistency', () => {
-        const a = new Date(2018, 8, 10);
-        const b = new Date(2018, 9, 10);
-        const c = new Date('2018-11-10');
-        const d = false;
-        const e = 1536530400000;
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(a, c)).to.eql(false);
-        expect(equal(a, d)).to.eql(false);
-        expect(equal(a, e)).to.eql(false);
-    });
-
-//
-//  RegExp
-//
-
-    it ('complex - RegExp : correctly flag equal', () => {
-        const a = /abcdefg/i;
-        const b = /abcdefg/i;
-        const c = new RegExp('abcdefg', 'i');
-        const d = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
-        const e = new RegExp('^\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*(\\.\\w{2,3})+$');
-        expect(equal(a, b)).to.eql(true);
-        expect(equal(a, c)).to.eql(true);
-        expect(equal(d, e)).to.eql(true);
-    });
-
-    it ('complex - RegExp : correctly flag inconsistency', () => {
-        const a = /abcdefg/i;
-        const b = /abcdefg/;
-        const c = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
-        const d = new RegExp('^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$');
-        const e = 'abcdefg';
-        const f = true;
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(c, d)).to.eql(false);
-        expect(equal(a, e)).to.eql(false);
-        expect(equal(a, f)).to.eql(false);
-    });
-
-//
-//  Array
-//
-
-    it ('complex - Array : correctly flag equal', () => {
-        const a = [0, 1, 2];
-        const b = [0, 1, 2];
-        const c = [
-            0,
-            { a: 'Valkyrie rules' },
-            new RegExp('abcdefg', 'i'),
-            true,
-            false,
-            [
-                1,
-                2,
-                3,
-                [
-                    new Date(2018, 9, 19),
-                    5,
-                    'the secret to life is 42',
-                    [
-                        6,
-                        7,
-                        8
-                    ],
-                    {
-                        a: 'hello world',
-                        b: [0, 1, { c: 'foobar' }]
-                    }
-                ]
-            ]
-        ];
-        const d = [
-            0,
-            { a: 'Valkyrie rules' },
-            new RegExp('abcdefg', 'i'),
-            true,
-            false,
-            [
-                1,
-                2,
-                3,
-                [
-                    new Date(2018, 9, 19),
-                    5,
-                    'the secret to life is 42',
-                    [
-                        6,
-                        7,
-                        8
-                    ],
-                    {
-                        a: 'hello world',
-                        b: [0, 1, { c: 'foobar' }]
-                    }
-                ]
-            ]
-        ];
-        const e = ['hello', 'world', 'foo', 1, 2];
-        const f = ['hello', 'world', 'foo', 1, 2];
-        expect(equal(a, b)).to.eql(true);
-        expect(equal(c, d)).to.eql(true);
-        expect(equal(e, f)).to.eql(true);
-        expect(equal([], [])).to.eql(true);
-    });
-
-    it ('complex - Array : correctly flag inconsistency', () => {
-        const a = [0, 1, 2];
-        const b = [0, 1, 3];
-        const c = [
-            0,
-            { a: 'Valkyrie rulez' },
-            new RegExp('abcdefg', 'i'),
-            true,
-            false,
-            [
-                1,
-                2,
-                3,
-                [
-                    new Date(2018, 9, 19),
-                    5,
-                    'the secret to life is 42',
-                    [
-                        6,
-                        7,
-                        8
-                    ],
-                    {
-                        a: 'hello world',
-                        b: [0, 1, { c: 'foobar' }]
-                    }
-                ]
-            ]
-        ];
-        const d = [
-            0,
-            { a: 'Valkyrie rules' },
-            new RegExp('abcdefg', 'i'),
-            true,
-            false,
-            [
-                1,
-                2,
-                3,
-                [
-                    new Date(2018, 9, 19),
-                    5,
-                    'the secret to life is 43',
-                    [
-                        6,
-                        7,
-                        8
-                    ],
-                    {
-                        a: 'hello world',
-                        b: [0, 1, { c: 'footbar' }]
-                    }
-                ]
-            ]
-        ];
-        const e = ['hello', 'warld', 'foo', 1, 2];
-        const f = ['hello', 'world', 'foo', 1, 2];
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(c, d)).to.eql(false);
-        expect(equal(e, f)).to.eql(false);
-    });
-
-//
-//  Object
-//
-
-    it ('complex - Object : correctly flag equal', () => {
-        const a = {
-            foo: 'bar',
-            a: 1,
-            b: 2,
-            c: [
-                0,
-                1,
-                2,
-                3,
-                { x : [0, 'Hello', 'world'], y: 'foobar42', z: 42 }
-            ],
-        };
-        const b = {
-            foo: 'bar',
-            a: 1,
-            b: 2,
-            c: [
-                0,
-                1,
-                2,
-                3,
-                { x : [0, 'Hello', 'world'], y: 'foobar42', z: 42 }
-            ],
-        };
-        const c = { a: new Date(2018, 9, 10), b: new RegExp('abcdefg', 'i'), c: true, d: 0.001 };
-        const d = { a: new Date(2018, 9, 10), b: new RegExp('abcdefg', 'i'), c: true, d: 0.001 };
-        expect(equal(a, b)).to.eql(true);
-        expect(equal(c, d)).to.eql(true);
-    });
-
-    it ('complex - Object : correctly flag inconsistency', () => {
-        const a = {
-            fooz: 'bar',
-            a: 1,
-            b: 3,
-            c: [
-                0,
-                1,
-                2,
-                3,
-                { x : [0, 'Hello', 'world'], y: 'foobar42', z: 42 }
-            ],
-        };
-        const b = {
-            foo: 'bar',
-            a: 1,
-            b: 2,
-            c: [
-                0,
-                1,
-                2,
-                3,
-                { x : [0, 'Hello', 'world'], y: 'foobar42', z: 42 }
-            ],
-        };
-        const c = { a: new Date(2018, 9, 10), b: new RegExp('abcdefg', 'i'), c: true, d: 0.001 };
-        const d = { a: new Date(2018, 10, 10), b: new RegExp('abcdefg', 'i'), c: true, d: 0.001 };
-        expect(equal(a, b)).to.eql(false);
-        expect(equal(c, d)).to.eql(false);
-    });
-
-});

package/test/src/function.test.js

@@ -1,215 +0,0 @@
-'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', () => {
-        let vals = fnStringValues();
-        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)).to.eql(false);
-    });
-
-    it ('not see a boolean as a function', () => {
-        let vals = fnBooleanValues();
-        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)).to.eql(false);
-    });
-
-    it ('not see an object as a function', () => {
-        let vals = fnObjectValues();
-        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)).to.eql(false);
-    });
-
-    it ('not see a date as a function', () => {
-        let vals = fnDateValues();
-        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)).to.eql(false);
-    });
-
-    it ('see a function as a function', () => {
-        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 {
-            obj     = { fn : noop };
-            rslt    = undefined;
-            var_a   = 42;
-            thrown  = false;
-
-            spy_fn = spy(obj, 'fn');
-            rslt = obj.fn(var_a);
-        } catch (err) {
-            thrown = true;
-        }
-    });
-
-    it ('execute the function when called', () => {
-        expect(spy_fn).to.have.been.called;
-    });
-
-    it ('return nothing', () => {
-        expect(rslt).to.eql(undefined);
-    });
-
-    it ('not affect parameters', () => {
-        expect(var_a).to.eql(42);
-    });
-
-    it ('not throw an error', () => {
-        expect(thrown).to.eql(false);
-    });
-});
-
-describe("Function - noopreturn", () => {
-    let obj, rslt, thrown, var_a;
-    let spy_fn = false;
-
-    beforeEach(() => {
-        try {
-            obj     = { fn : noopreturn };
-            rslt    = undefined;
-            var_a   = 42;
-            thrown  = false;
-
-            spy_fn = spy(obj, 'fn');
-            rslt = obj.fn(var_a);
-            rslt = obj.fn(obj.fn(var_a));
-        } catch (err) {
-            thrown = true;
-        }
-    });
-
-    it ('execute the function when called', () => {
-        expect(spy_fn).to.have.been.called;
-    });
-
-    it ('return passed variable', () => {
-        expect(rslt).to.eql(42);
-    });
-
-    it ('not affect parameters', () => {
-        expect(var_a).to.eql(42);
-    });
-
-    it ('not throw an error', () => {
-        expect(thrown).to.eql(false);
-    });
-});
-
-describe("Function - noopresolve", () => {
-    let obj, rslt, thrown, var_a;
-    let spy_fn = false;
-
-    beforeEach(() => {
-        try {
-            obj     = {fn : noopresolve};
-            rslt    = undefined;
-            var_a   = 42;
-            thrown  = false;
-
-            spy_fn = spy(obj, 'fn');
-            rslt = obj.fn(var_a);
-        } catch (err) {
-            thrown = true;
-        }
-    });
-
-    it ('execute the function when called', () => {
-        expect(spy_fn).to.have.been.called;
-    });
-
-    it ('returns a promise', (next) => {
-        expect(rslt instanceof Promise).to.eql(true);
-        next();
-    });
-
-    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).to.eql(42);
-            next();
-        });
-    });
-
-    it ('not affect parameters', () => {
-        expect(var_a).to.eql(42);
-    });
-
-    it ('not throw an error', () => {
-        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(205);
-        const timer_end = new Date() - timer_start;
-        expect(timer_end >= 200).to.eql(true);
-    });
-});

package/test/src/hash.test.js

@@ -1,110 +0,0 @@
-'use strict';
-
-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();
-        assert.typeOf(g, 'string');
-    });
-
-    it ('have exactly 36 characters', () => {
-        let g = guid();
-        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)).to.eql(true);
-    });
-
-    it ('be unique (50.000 benchmark)', () => {
-        const cache = {};
-        let cursor = 0;
-
-        while (cursor < 50000) {
-            cache[guid()] = true;
-            cursor++;
-        }
-
-        expect(Object.keys(cache).length).to.eql(cursor);
-    });
-});
-
-describe("Hash - FNV1A", () => {
-    it ('should output the same hash for the same value', () => {
-        const a_1 = fnv1A('Hello World');
-        const a_2 = fnv1A('Hello World');
-        const b_1 = fnv1A([0, 1, 2, 3, 4, 5]);
-        const b_2 = fnv1A([0, 1, 2, 3, 4, 5]);
-        const c_1 = fnv1A({
-            foo: 'bar',
-            a : true,
-            b : false,
-            c : {
-                d : [0, 1, 2, 3, { a: 'hello', b: 'world', c: [0, 1, 2, 3] }],
-                e : 10234,
-            },
-        });
-        const c_2 = fnv1A({
-            foo: 'bar',
-            a : true,
-            b : false,
-            c : {
-                d : [0, 1, 2, 3, { a: 'hello', b: 'world', c: [0, 1, 2, 3] }],
-                e : 10234,
-            },
-        });
-        const d_1 = fnv1A(new Date(2018, 12, 5));
-        const d_2 = fnv1A(new Date(2018, 12, 5));
-        const d_3 = fnv1A(new Date(2018, 12, 4));
-        const e_1 = fnv1A(new RegExp('abcdefg', 'i'));
-        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).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()) }).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("")).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);
-    });
-
-});