@valkyriestudios/utils 4.2.0 → 5.0.0

package/test/src/deep.test.js

@@ -7,6 +7,15 @@ import deepSet      from '../../src/deep/set';
 import deepGet      from '../../src/deep/get';
 import deepDefine   from '../../src/deep/define';
 
+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;
+
 const original = {
     a : 1,
     test : [1, 2, 3],
@@ -31,10 +40,10 @@ describe("Deep - deepSeal", () => {
     });
 
     it ('isSealed flag on every nested object', function () {
-        expect(Object.isSealed(subject)).toEqual(true);
-        expect(Object.isSealed(subject.test)).toEqual(true);
-        expect(Object.isSealed(subject.c)).toEqual(true);
-        expect(Object.isSealed(subject.c.e)).toEqual(true);
+        expect(Object.isSealed(subject)).to.eql(true);
+        expect(Object.isSealed(subject.test)).to.eql(true);
+        expect(Object.isSealed(subject.c)).to.eql(true);
+        expect(Object.isSealed(subject.c.e)).to.eql(true);
     });
 
     it ('allow adjusting properties', function () {
@@ -50,12 +59,12 @@ describe("Deep - deepSeal", () => {
             return equal(subject, original);
         }
 
-        expect(fn('a', 'Hello world')).toEqual(false);
-        expect(fn('c.d', null)).toEqual(false);
-        expect(fn('c.e.f', 'foo')).toEqual(false);
-        expect(fn('test', [3, 6, 9])).toEqual(false);
-        expect(fn('test', 42)).toEqual(false);
-        expect(function () { return fn('foo', 'bar') }).toThrowError(TypeError);
+        expect(fn('a', 'Hello world')).to.eql(false);
+        expect(fn('c.d', null)).to.eql(false);
+        expect(fn('c.e.f', 'foo')).to.eql(false);
+        expect(fn('test', [3, 6, 9])).to.eql(false);
+        expect(fn('test', 42)).to.eql(false);
+        expect(function () { return fn('foo', 'bar') }).to.throw(TypeError);
     });
 
     it ('not allow assigning new properties', function () {
@@ -63,8 +72,8 @@ describe("Deep - deepSeal", () => {
             deepSet(subject, key);
         }
 
-        expect(function () { fn('true') }).toThrowError(TypeError);
-        expect(function () { fn('c.e.g') }).toThrowError(TypeError);
+        expect(function () { fn('true') }).to.throw(TypeError);
+        expect(function () { fn('c.e.g') }).to.throw(TypeError);
     });
 
     it ('not allow defining properties', function () {
@@ -74,14 +83,14 @@ describe("Deep - deepSeal", () => {
                     return 'foo';
                 },
             });
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 
     it ('throw a type error if something different than an object/array is passed', function () {
-        expect(function () { deepSeal() }).toThrowError(TypeError);
-        expect(function () { deepSeal(42) }).toThrowError(TypeError);
-        expect(function () { deepSeal('foo') }).toThrowError(TypeError);
-        expect(function () { deepSeal(false) }).toThrowError(TypeError);
+        expect(function () { deepSeal() }).to.throw(TypeError);
+        expect(function () { deepSeal(42) }).to.throw(TypeError);
+        expect(function () { deepSeal('foo') }).to.throw(TypeError);
+        expect(function () { deepSeal(false) }).to.throw(TypeError);
     });
 });
 
@@ -93,10 +102,10 @@ describe("Deep - deepFreeze", () => {
     });
 
     it ('isFrozen flag on every nested object', function () {
-        expect(Object.isFrozen(subject)).toEqual(true);
-        expect(Object.isFrozen(subject.test)).toEqual(true);
-        expect(Object.isFrozen(subject.c)).toEqual(true);
-        expect(Object.isFrozen(subject.c.e)).toEqual(true);
+        expect(Object.isFrozen(subject)).to.eql(true);
+        expect(Object.isFrozen(subject.test)).to.eql(true);
+        expect(Object.isFrozen(subject.c)).to.eql(true);
+        expect(Object.isFrozen(subject.c.e)).to.eql(true);
     });
 
     it ('not allow adjusting properties', function () {
@@ -112,19 +121,19 @@ describe("Deep - deepFreeze", () => {
             return equal(subject, original);
         }
 
-        expect(function () { fn('a', 'Hello world') }).toThrowError(TypeError);
-        expect(function () { fn('c.d', null) }).toThrowError(TypeError);
-        expect(function () { fn('c.e.f', 'foo') }).toThrowError(TypeError);
-        expect(function () { fn('test', [3, 6, 9]) }).toThrowError(TypeError);
-        expect(function () { fn('test', 42) }).toThrowError(TypeError);
+        expect(function () { fn('a', 'Hello world') }).to.throw(TypeError);
+        expect(function () { fn('c.d', null) }).to.throw(TypeError);
+        expect(function () { fn('c.e.f', 'foo') }).to.throw(TypeError);
+        expect(function () { fn('test', [3, 6, 9]) }).to.throw(TypeError);
+        expect(function () { fn('test', 42) }).to.throw(TypeError);
     });
 
     it ('not allow assigning new properties', function () {
         function fn (subject, key) {
             deepSet(subject, key);
         }
-        expect(function () { fn('true') }).toThrowError(TypeError);
-        expect(function () { fn('c.e.g') }).toThrowError(TypeError);
+        expect(function () { fn('true') }).to.throw(TypeError);
+        expect(function () { fn('c.e.g') }).to.throw(TypeError);
     });
 
     it ('not allow defining properties', function () {
@@ -134,14 +143,14 @@ describe("Deep - deepFreeze", () => {
                     return 'foo';
                 },
             });
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 
     it ('throw a type error if something different than an object/array is passed', function () {
-        expect(function () { deepFreeze() }).toThrowError(TypeError);
-        expect(function () { deepFreeze(42) }).toThrowError(TypeError);
-        expect(function () { deepFreeze('foo') }).toThrowError(TypeError);
-        expect(function () { deepFreeze(false) }).toThrowError(TypeError);
+        expect(function () { deepFreeze() }).to.throw(TypeError);
+        expect(function () { deepFreeze(42) }).to.throw(TypeError);
+        expect(function () { deepFreeze('foo') }).to.throw(TypeError);
+        expect(function () { deepFreeze(false) }).to.throw(TypeError);
     });
 });
 
@@ -173,36 +182,75 @@ describe("Deep - deepSet", () => {
         deepSet(subject, 'd.4.e', 'world');
         deepSet(subject, 'd.4.f.0', 'Y');
 
-        expect(subject.c).toEqual(4);
-        expect(subject.d[0]).toEqual(100);
-        expect(subject.d[4].e).toEqual('world');
-        expect(subject.d[4].f[0]).toEqual('Y');
+        expect(subject.c).to.eql(4);
+        expect(subject.d[0]).to.eql(100);
+        expect(subject.d[4].e).to.eql('world');
+        expect(subject.d[4].f[0]).to.eql('Y');
     });
 
     it ('correctly set a value on an inexisting key', function () {
         deepSet(subject, 'f', 42);
         deepSet(subject, 'e.a.b.c.d.e.f.g.h', 'valkyrie rules');
         deepSet(subject, 'e.b', [0, 1, 2]);
+        deepSet(subject, ['q', '', 0], 'valkyrie is cool');
+        deepSet(subject, ['q', 1], 'valkyrie is fun');
 
-        expect(subject.f).toEqual(42);
-        expect(subject.e.a.b.c.d.e.f.g.h).toEqual('valkyrie rules');
-        expect(subject.e.b).toEqual([0, 1, 2]);
+        expect(subject.f).to.eql(42);
+        expect(subject.e.a.b.c.d.e.f.g.h).to.eql('valkyrie rules');
+        expect(subject.e.b).to.eql([0, 1, 2]);
+        expect(subject.q).to.deep.eql({0: 'valkyrie is cool', 1: 'valkyrie is fun'});
     });
 
     it ('correctly defines a value on an existing key', function () {
         deepSet(subject, 'a', { get: () => 5 }, true);
 
-        expect(subject.a).toEqual(5);
-        expect(Object.getOwnPropertyDescriptor(subject, 'a').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(subject, 'a').get).toBe('function');
+        expect(subject.a).to.eql(5);
+        expect(Object.getOwnPropertyDescriptor(subject, 'a').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(subject, 'a').get, 'function');
     });
 
     it ('correctly defines a value on an inexisting key', function () {
         deepSet(subject, 'g', { get: () => 5 }, true);
 
-        expect(subject.g).toEqual(5);
-        expect(Object.getOwnPropertyDescriptor(subject, 'g').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(subject, 'g').get).toBe('function');
+        expect(subject.g).to.eql(5);
+        expect(Object.getOwnPropertyDescriptor(subject, 'g').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(subject, 'g').get, 'function');
+    });
+
+    it ('correctly throws an error on failure', function () {
+        expect(function () {
+            deepSet('hello', '2');
+        }).to.throw(TypeError);
+    });
+
+    it ('correctly throws when not passed an object or array', function () {
+        for (let el of [
+            1, 2, 3, .5, 0.4, -1, true, new Date(), /1/g, false, 'hello', 'abc'
+        ]) {
+            expect(function () {
+                deepSet(el, '2');
+            }).to.throw(TypeError);
+        }
+    });
+
+    it ('correctly throws when not passed a string/array key', function () {
+        let obj = {a: 'bi'};
+        for (let el of [
+            {a:1}, true, new Date(), /1/g, false, 123, 0.123
+        ]) {
+            expect(function () {
+                deepSet(obj, el);
+            }).to.throw(TypeError);
+        }
+        expect(obj).to.deep.equal({a: 'bi'});
+    });
+
+    it ('correctly throws when passed an empty string path', function () {
+        let obj = {a: 'bi'};
+        expect(function () {
+            deepSet(obj, '');
+        }).to.throw(TypeError);
+        expect(obj).to.deep.equal({a: 'bi'});
     });
 });
 
@@ -237,25 +285,66 @@ describe("Deep - deepGet", () => {
     it ('correctly retrieves a value on an existing key', function () {
         expect(function () {
             deepGet('hello', '2');
-        }).toThrowError(TypeError);
-        expect(deepGet(subject, 'a')).toEqual(1);
-        expect(deepGet(subject, 'd[0]')).toEqual(0);
-        expect(deepGet(subject, 'd.0')).toEqual(0);
-        expect(deepGet(subject, 'd.5')).toEqual(undefined);
-        expect(deepGet(subject, 'd[4].e')).toEqual('Hello');
-        expect(deepGet(subject, 'd.4.f[2]')).toEqual('c');
-        expect(deepGet(subject, 'd.4.g')).toEqual('');
-        expect(deepGet(subject, 'h')).toEqual('');
-        expect(deepGet(subject, 'i')).toEqual(false);
-        expect(deepGet(subject, 'j')).toEqual(true);
-        expect(deepGet(subject, 'd.4.k')).toEqual(false);
-        expect(deepGet(subject, 'l')).toEqual([]);
+        }).to.throw(TypeError);
+        expect(deepGet(subject, 'a')).to.eql(1);
+        expect(deepGet(subject, 'd[0]')).to.eql(0);
+        expect(deepGet(subject, 'd.0')).to.eql(0);
+        expect(deepGet(subject, 'd.5')).to.eql(undefined);
+        expect(deepGet(subject, 'd[4].e')).to.eql('Hello');
+        expect(deepGet(subject, 'd.4.f[2]')).to.eql('c');
+        expect(deepGet(subject, 'd.4.g')).to.eql('');
+        expect(deepGet(subject, 'h')).to.eql('');
+        expect(deepGet(subject, 'i')).to.eql(false);
+        expect(deepGet(subject, 'j')).to.eql(true);
+        expect(deepGet(subject, 'd.4.k')).to.eql(false);
+        expect(deepGet(subject, 'l')).to.eql([]);
     });
 
     it ('correctly throws an error on failure', function () {
         expect(function () {
             deepGet('hello', '2');
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
+    });
+
+    it ('correctly throws when not passed an object or array', function () {
+        for (let el of [
+            1, 2, 3, .5, 0.4, -1, true, new Date(), /1/g, false, 'hello', 'abc'
+        ]) {
+            expect(function () {
+                deepGet(el, '2');
+            }).to.throw(TypeError);
+        }
+    });
+
+    it ('correctly throws when not passed a string key', function () {
+        for (let el of [
+            {a:1}, [0,1,2], true, new Date(), /1/g, false, 123, 0.123
+        ]) {
+            expect(function () {
+                deepGet({a: 'bi'}, el);
+            }).to.throw(TypeError);
+        }
+    });
+
+    it ('correctly throws when passed an empty string path', function () {
+        expect(function () {
+            deepGet({a: 'bi'}, '');
+        }).to.throw(TypeError);
+    });
+
+    it ('correctly returns object when passed a single path string key and get_parent is set to true', function () {
+        let out = deepGet({a: 'bi'}, 'a', true);
+        expect(out).to.deep.equal({a: 'bi'});
+    });
+
+    it ('correctly returns object parent when passed a multi path string key and get_parent is set to true', function () {
+        let obj = {a: {b: {c: 'hi'}}};
+
+        let out = deepGet(obj, 'a.b.c', true);
+        expect(out).to.deep.equal({c: 'hi'});
+
+        let out2 = deepGet(obj, 'a.b', true);
+        expect(out2).to.deep.equal({b: {c: 'hi'}});
     });
 });
 
@@ -284,16 +373,16 @@ describe("Deep - deepDefine", () => {
     it ('correctly defines a value on an existing key', function () {
         deepDefine(subject, 'a', { get: () => 5 });
 
-        expect(subject.a).toEqual(5);
-        expect(Object.getOwnPropertyDescriptor(subject, 'a').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(subject, 'a').get).toBe('function');
+        expect(subject.a).to.eql(5);
+        expect(Object.getOwnPropertyDescriptor(subject, 'a').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(subject, 'a').get, 'function');
     });
 
     it ('correctly defines a value on an inexisting key', function () {
         deepDefine(subject, 'g', { get: () => 5 });
 
-        expect(subject.g).toEqual(5);
-        expect(Object.getOwnPropertyDescriptor(subject, 'g').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(subject, 'g').get).toBe('function');
+        expect(subject.g).to.eql(5);
+        expect(Object.getOwnPropertyDescriptor(subject, 'g').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(subject, 'g').get, 'function');
     });
 });

package/test/src/equal.test.js

@@ -3,6 +3,15 @@
 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
@@ -11,7 +20,7 @@ describe("Equal", () => {
     it ('primitive - undefined : correctly flag equal', () => {
         const a = undefined;
         const b = undefined;
-        expect(equal(a, b)).toEqual(true);
+        expect(equal(a, b)).to.eql(true);
     });
 
     it ('primitive - undefined : correctly flag inconsistency', () => {
@@ -20,10 +29,10 @@ describe("Equal", () => {
         const c = 'foo';
         const d = false;
         const e = 0;
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(a, c)).toEqual(false);
-        expect(equal(a, d)).toEqual(false);
-        expect(equal(a, e)).toEqual(false);
+        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);
     });
 
 //
@@ -33,7 +42,7 @@ describe("Equal", () => {
     it ('primitive - null : correctly flag equal', () => {
         const a = null;
         const b = null;
-        expect(equal(a, b)).toEqual(true);
+        expect(equal(a, b)).to.eql(true);
     });
 
     it ('primitive - null : correctly flag inconsistency', () => {
@@ -42,10 +51,10 @@ describe("Equal", () => {
         const c = 'foo';
         const d = false;
         const e = 0;
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(a, c)).toEqual(false);
-        expect(equal(a, d)).toEqual(false);
-        expect(equal(a, e)).toEqual(false);
+        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);
     });
 
 //
@@ -55,7 +64,7 @@ describe("Equal", () => {
     it ('primitive - string : correctly flag equal', () => {
         const a = 'hello';
         const b = 'hello';
-        expect(equal(a, b)).toEqual(true);
+        expect(equal(a, b)).to.eql(true);
     });
 
     it ('primitive - string : correctly flag inconsistency', () => {
@@ -65,11 +74,11 @@ describe("Equal", () => {
         const d = undefined;
         const e = false;
         const f = new String('foo');
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(a, c)).toEqual(false);
-        expect(equal(a, d)).toEqual(false);
-        expect(equal(a, e)).toEqual(false);
-        expect(equal(a, f)).toEqual(false);
+        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);
     });
 
 //
@@ -83,9 +92,9 @@ describe("Equal", () => {
         const d = true;
         const e = new Boolean(false);
         const f = new Boolean(false);
-        expect(equal(a, b)).toEqual(true);
-        expect(equal(c, d)).toEqual(true);
-        expect(equal(e, f)).toEqual(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', () => {
@@ -95,11 +104,11 @@ describe("Equal", () => {
         const d = 0;
         const e = new Boolean(false);
         const f = new Boolean(true);
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(a, c)).toEqual(false);
-        expect(equal(b, d)).toEqual(false);
-        expect(equal(a, e)).toEqual(false);
-        expect(equal(b, f)).toEqual(false);
+        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);
     });
 
 //
@@ -112,9 +121,9 @@ describe("Equal", () => {
         const c = 512.00000000000;
         const d = NaN;
         const e = NaN;
-        expect(equal(a, b)).toEqual(true);
-        expect(equal(a, c)).toEqual(true);
-        expect(equal(d, e)).toEqual(true);
+        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', () => {
@@ -125,12 +134,12 @@ describe("Equal", () => {
         const e = undefined;
         const f = null;
         const g = new Number(512);
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(a, c)).toEqual(false);
-        expect(equal(a, d)).toEqual(false);
-        expect(equal(c, e)).toEqual(false);
-        expect(equal(c, f)).toEqual(false);
-        expect(equal(a, g)).toEqual(false);
+        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);
     });
 
 //
@@ -141,8 +150,8 @@ describe("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)).toEqual(true);
-        expect(equal(a, c)).toEqual(true);
+        expect(equal(a, b)).to.eql(true);
+        expect(equal(a, c)).to.eql(true);
     });
 
     it ('complex - Date : correctly flag inconsistency', () => {
@@ -151,10 +160,10 @@ describe("Equal", () => {
         const c = new Date('2018-11-10');
         const d = false;
         const e = 1536530400000;
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(a, c)).toEqual(false);
-        expect(equal(a, d)).toEqual(false);
-        expect(equal(a, e)).toEqual(false);
+        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);
     });
 
 //
@@ -167,9 +176,9 @@ describe("Equal", () => {
         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)).toEqual(true);
-        expect(equal(a, c)).toEqual(true);
-        expect(equal(d, e)).toEqual(true);
+        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', () => {
@@ -179,10 +188,10 @@ describe("Equal", () => {
         const d = new RegExp('^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$');
         const e = 'abcdefg';
         const f = true;
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(c, d)).toEqual(false);
-        expect(equal(a, e)).toEqual(false);
-        expect(equal(a, f)).toEqual(false);
+        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);
     });
 
 //
@@ -246,10 +255,10 @@ describe("Equal", () => {
         ];
         const e = ['hello', 'world', 'foo', 1, 2];
         const f = ['hello', 'world', 'foo', 1, 2];
-        expect(equal(a, b)).toEqual(true);
-        expect(equal(c, d)).toEqual(true);
-        expect(equal(e, f)).toEqual(true);
-        expect(equal([], [])).toEqual(true);
+        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', () => {
@@ -309,9 +318,9 @@ describe("Equal", () => {
         ];
         const e = ['hello', 'warld', 'foo', 1, 2];
         const f = ['hello', 'world', 'foo', 1, 2];
-        expect(equal(a, b)).toEqual(false);
-        expect(equal(c, d)).toEqual(false);
-        expect(equal(e, f)).toEqual(false);
+        expect(equal(a, b)).to.eql(false);
+        expect(equal(c, d)).to.eql(false);
+        expect(equal(e, f)).to.eql(false);
     });
 
 //
@@ -345,8 +354,8 @@ describe("Equal", () => {
         };
         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)).toEqual(true);
-        expect(equal(c, d)).toEqual(true);
+        expect(equal(a, b)).to.eql(true);
+        expect(equal(c, d)).to.eql(true);
     });
 
     it ('complex - Object : correctly flag inconsistency', () => {
@@ -376,8 +385,8 @@ describe("Equal", () => {
         };
         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)).toEqual(false);
-        expect(equal(c, d)).toEqual(false);
+        expect(equal(a, b)).to.eql(false);
+        expect(equal(c, d)).to.eql(false);
     });
 
 });