@valkyriestudios/utils 4.2.0 → 5.0.0

package/test/src/object.test.js

@@ -19,59 +19,62 @@ 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("Object - isObject", () => {
     it ('not see a string as an object', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 
     it ('not see a numeric value as an object', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 
     it ('not see a boolean as an object', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 
     it ('not see a regex as an object', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 
     it ('see an object as an object', () => {
         let vals = fnObjectValues();
-        for (let el of vals) expect(isObject(el)).toEqual(true);
+        for (let el of vals) expect(isObject(el)).to.eql(true);
     });
 
     it ('not see a nullable as an object', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 
     it ('not see a date as an object', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 
     it ('not see an array as an object', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 
     it ('not see a function as an object', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
-    });
-
-    it ('not see formdata as an object', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isObject(el)).toEqual(false);
+        for (let el of vals) expect(isObject(el)).to.eql(false);
     });
 });
 
@@ -87,38 +90,38 @@ describe("Object - pick", () => {
     };
 
     it ('correctly retrieve the selected keys', () => {
-        expect(pick(subject, ['a'])).toEqual({ a: 100 });
-        expect(pick(subject, ['a', 'b'])).toEqual({ a: 100, b: 200 });
-        expect(pick(subject, ['a', 'c.e'])).toEqual({ a: 100, c: { e: true }});
-        expect(pick(subject, ['a', 'c.d', 'c.f'])).toEqual({ a: 100, c: { d: 5, f: [0, 1, 2] }});
-        expect(pick(subject, ['a', 'b', 'd'])).toEqual({ a: 100, b: 200 });
+        expect(pick(subject, ['a'])).to.eql({ a: 100 });
+        expect(pick(subject, ['a', 'b'])).to.eql({ a: 100, b: 200 });
+        expect(pick(subject, ['a', 'c.e'])).to.eql({ a: 100, c: { e: true }});
+        expect(pick(subject, ['a', 'c.d', 'c.f'])).to.eql({ a: 100, c: { d: 5, f: [0, 1, 2] }});
+        expect(pick(subject, ['a', 'b', 'd'])).to.eql({ a: 100, b: 200 });
     });
 
     it ('returns an empty object when nothing is passed', () => {
-        expect(pick()).toEqual({});
+        expect(pick()).to.eql({});
     });
 
     it ('returns an empty object when no keys are passed', () => {
-        expect(pick(subject)).toEqual({});
+        expect(pick(subject)).to.eql({});
     });
 
     it ('throws a type error when passed something else than an object', () => {
         expect(function() {
             pick(false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
         expect(function() {
             pick(subject, false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 });
 
 describe("Object - merge", () => {
     it ('returns the target object if only passed a target', () => {
-        expect(merge({a: 1, b: 2})).toEqual({a: 1, b:2 });
+        expect(merge({a: 1, b: 2})).to.eql({a: 1, b:2 });
     });
 
     it ('merges keys correctly', () => {
-        expect(merge({ a: 1, b: 2, c: true}, { a: 5, c: false })).toEqual({ a: 5, b: 2, c: false });
+        expect(merge({ a: 1, b: 2, c: true}, { a: 5, c: false })).to.eql({ a: 5, b: 2, c: false });
         expect(merge({
             a: [0, 1, 2, 3],
             b: {
@@ -130,7 +133,7 @@ describe("Object - merge", () => {
                 foo: 'bar',
                 hello: 'world',
             },
-        }, { a: ['foo', 'bar'], b: { available: true }, c: { hello: 'core' }})).toEqual({
+        }, { a: ['foo', 'bar'], b: { available: true }, c: { hello: 'core' }})).to.eql({
             a: ['foo', 'bar'],
             b: {
                 name: 'utils',
@@ -145,13 +148,13 @@ describe("Object - merge", () => {
     });
 
     it ('does not merge in keys that are not defined in the target', () => {
-        expect(merge({ a: 1, b: 2 }, { a: 2, b: 3, c: 4 })).toEqual({ a: 2, b: 3 });
+        expect(merge({ a: 1, b: 2 }, { a: 2, b: 3, c: 4 })).to.eql({ a: 2, b: 3 });
     });
 
     it ('throws a type error when passed something else than an object', () => {
         expect(function() {
             merge(false, { a: 2 })
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 });
 
@@ -177,8 +180,8 @@ describe("Object - forValues", () => {
     });
 
     it ('correctly executes the cb on every value', () => {
-        expect(forValues(subject_sum, (key, val) => val + 1)).toEqual({ a: 2, b: 3, c: 4 });
-        expect(forValues(subject_obj, (key, val) => Object.assign(val, { name: `${val.first_name} ${val.last_name}` }))).toEqual({
+        expect(forValues(subject_sum, (key, val) => val + 1)).to.eql({ a: 2, b: 3, c: 4 });
+        expect(forValues(subject_obj, (key, val) => Object.assign(val, { name: `${val.first_name} ${val.last_name}` }))).to.eql({
             1823 : {
                 name: 'Jane Doe',
                 first_name: 'Jane',
@@ -195,55 +198,55 @@ describe("Object - forValues", () => {
                 last_name: 'The Clown',
             },
         });
-        expect(forValues(subject_sum, noopreturn)).toEqual(subject_sum);
+        expect(forValues(subject_sum, noopreturn)).to.eql(subject_sum);
     });
 
     it ('throws a type error when passed something else than an object', () => {
         expect(function() {
             forValues(false, (key, val) => val + 1);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 });
 
 describe("Object - zip", () => {
     it ('returns an empty object when called without parameters', () => {
-        expect(zip()).toEqual({});
+        expect(zip()).to.eql({});
     });
 
     it ('only returns a zipped object for the keys that are passed', () => {
-        expect(zip(['a'], [1, 2, 3])).toEqual({a: 1});
+        expect(zip(['a'], [1, 2, 3])).to.eql({a: 1});
     });
 
     it ('defaults to null when passed with only keys', () => {
-        expect(zip(['a', 'b', 'c'])).toEqual({a: null, b: null, c: null});
+        expect(zip(['a', 'b', 'c'])).to.eql({a: null, b: null, c: null});
     });
 
     it ('defaults to the provided default when passed one', () => {
-        expect(zip(['a', 'b', 'c'], false, false)).toEqual({a: false, b: false, c: false});
+        expect(zip(['a', 'b', 'c'], false, false)).to.eql({a: false, b: false, c: false});
     });
 
     it ('zips an object when passed with the correct parameters', () => {
-        expect(zip(['a', 'b', 'c'], [1, 2, 3])).toEqual({ a: 1, b: 2, c: 3});
+        expect(zip(['a', 'b', 'c'], [1, 2, 3])).to.eql({ a: 1, b: 2, c: 3});
     });
 
     it ('throws a type error when passed something else than the expected parameters', () => {
         expect(function() {
             zip(false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
 
         expect(function() {
             zip(['a'], { hello: 'bar' });
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 });
 
 describe("Object - define", () => {
     it ('returns an empty object when called without parameters', () => {
-        expect(define()).toEqual({});
+        expect(define()).to.eql({});
     });
 
     it ('returns the same object when called with an empty properties object and an existing object', () => {
-        expect(define({}, {a: 1})).toEqual({a: 1});
+        expect(define({}, {a: 1})).to.eql({a: 1});
     });
 
     it ('defines properties that are passed without passing an existing object', () => {
@@ -258,22 +261,22 @@ describe("Object - define", () => {
             },
         });
 
-        expect(obj.a).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'a').get).toBe('function');
+        should.exist(obj.a);
+        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'a').get, 'function');
 
-        expect(obj.b).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'b').get).toBe(undefined);
-        expect(Object.getOwnPropertyDescriptor(obj, 'b').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'b').value).toBe('function');
+        should.exist(obj.b);
+        expect(Object.getOwnPropertyDescriptor(obj, 'b').get).to.eql(undefined);
+        expect(Object.getOwnPropertyDescriptor(obj, 'b').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'b').value, 'function');
 
-        const spy_a = spyOnProperty(obj, 'a', 'get').and.callThrough();
-        expect(obj.a).toBe(1);
-        expect(spy_a).toHaveBeenCalled();
+        const spy_a = spy(obj, 'a');
+        expect(obj.a).to.eql(1);
+        expect(spy_a).to.have.been.called;
 
-        const spy_b = spyOnProperty(obj, 'b', 'value').and.callThrough();
-        expect(obj.b()).toBe(2);
-        expect(spy_b).toHaveBeenCalled();
+        const spy_b = spy(obj, 'b');
+        expect(obj.b()).to.eql(2);
+        expect(spy_b).to.have.been.called;
     });
 
     it ('defines properties that are passed on an existing object', () => {
@@ -288,24 +291,24 @@ describe("Object - define", () => {
             },
         }, { c: 1 });
 
-        expect(obj.a).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'a').get).toBe('function');
+        should.exist(obj.a);
+        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'a').get, 'function');
 
-        expect(obj.b).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'b').get).toBe(undefined);
-        expect(Object.getOwnPropertyDescriptor(obj, 'b').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'b').value).toBe('function');
+        should.exist(obj.b);
+        expect(Object.getOwnPropertyDescriptor(obj, 'b').get).to.eql(undefined);
+        expect(Object.getOwnPropertyDescriptor(obj, 'b').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'b').value, 'function');
 
-        const spy_a = spyOnProperty(obj, 'a', 'get').and.callThrough();
-        expect(obj.a).toBe(1);
-        expect(spy_a).toHaveBeenCalled();
+        const spy_a = spy(obj, 'a');
+        expect(obj.a).to.eql(1);
+        expect(spy_a).to.have.been.called;
 
-        const spy_b = spyOnProperty(obj, 'b', 'value').and.callThrough();
-        expect(obj.b()).toBe(2);
-        expect(spy_b).toHaveBeenCalled();
+        const spy_b = spy(obj, 'b');
+        expect(obj.b()).to.eql(2);
+        expect(spy_b).to.have.been.called;
 
-        expect(obj.c).toBe(1);
+        expect(obj.c).to.eql(1);
     });
 
     it ('defines properties that are passed on an existing object', () => {
@@ -320,32 +323,32 @@ describe("Object - define", () => {
             },
         }, { a: 5 });
 
-        expect(obj.a).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'a').get).toBe('function');
+        should.exist(obj.a);
+        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'a').get, 'function');
 
-        expect(obj.b).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'b').get).toBe(undefined);
-        expect(Object.getOwnPropertyDescriptor(obj, 'b').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'b').value).toBe('function');
+        should.exist(obj.b);
+        expect(Object.getOwnPropertyDescriptor(obj, 'b').get).to.eql(undefined);
+        expect(Object.getOwnPropertyDescriptor(obj, 'b').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'b').value, 'function');
 
-        const spy_a = spyOnProperty(obj, 'a', 'get').and.callThrough();
-        expect(obj.a).toBe(1);
-        expect(spy_a).toHaveBeenCalled();
+        const spy_a = spy(obj, 'a');
+        expect(obj.a).to.eql(1);
+        expect(spy_a).to.have.been.called;
 
-        const spy_b = spyOnProperty(obj, 'b', 'value').and.callThrough();
-        expect(obj.b()).toBe(2);
-        expect(spy_b).toHaveBeenCalled();
+        const spy_b = spy(obj, 'b');
+        expect(obj.b()).to.eql(2);
+        expect(spy_b).to.have.been.called;
     });
 
     it ('throws a type error when passed something else than the expected parameters', () => {
         expect(function() {
             define(false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
 
         expect(function() {
             define({}, false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 });
 
@@ -353,21 +356,21 @@ describe("Object - defineFrozen", () => {
     it ('returns a frozen empty object when called without parameters', () => {
         const obj = defineFrozen();
 
-        expect(obj).toEqual({});
-        expect(Object.isFrozen(obj)).toEqual(true);
+        expect(obj).to.eql({});
+        expect(Object.isFrozen(obj)).to.eql(true);
         expect(function() {
             obj.b = false;
-        }).toThrowError();
+        }).to.throw();
     });
 
     it ('returns a frozen version of the same object when called with an empty properties object and an existing object', () => {
         const obj = defineFrozen({}, {a: 1});
 
-        expect(obj).toEqual({a: 1});
-        expect(Object.isFrozen(obj)).toEqual(true);
+        expect(obj).to.eql({a: 1});
+        expect(Object.isFrozen(obj)).to.eql(true);
         expect(function() {
             obj.a = 9999;
-        }).toThrowError();
+        }).to.throw();
     });
 
     it ('defines properties that are passed without passing an existing object, and freezes them', () => {
@@ -377,28 +380,28 @@ describe("Object - defineFrozen", () => {
             },
         });
 
-        expect(obj.a).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'a').get).toBe('function');
+        should.exist(obj.a);
+        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'a').get, 'function');
 
-        expect(Object.isFrozen(obj)).toEqual(true);
+        expect(Object.isFrozen(obj)).to.eql(true);
         expect(function () {
             Object.defineProperty(obj, {
                 x: {
                     get: () => 9999,
                 },
             });
-        }).toThrowError();
+        }).to.throw();
     });
 
     it ('throws a type error when passed something else than the expected parameters', () => {
         expect(function() {
             defineFrozen(false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
 
         expect(function() {
             defineFrozen({}, false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 });
 
@@ -406,24 +409,24 @@ describe("Object - defineSealed", () => {
     it ('returns a sealed empty object when called without parameters', () => {
         const obj = defineSealed();
 
-        expect(obj).toEqual({});
-        expect(Object.isSealed(obj)).toEqual(true);
+        expect(obj).to.eql({});
+        expect(Object.isSealed(obj)).to.eql(true);
         expect(function() {
             obj.b = false;
-        }).toThrowError();
+        }).to.throw();
     });
 
     it ('returns a sealed version of the same object when called with an empty properties object and an existing object', () => {
         const obj = defineSealed({}, {a: 1});
 
-        expect(obj).toEqual({a: 1});
-        expect(Object.isSealed(obj)).toEqual(true);
+        expect(obj).to.eql({a: 1});
+        expect(Object.isSealed(obj)).to.eql(true);
         expect(function() {
             obj.a = 9999;
-        }).not.toThrowError();
+        }).not.to.throw();
         expect(function() {
             obj.b = 9999;
-        }).toThrowError();
+        }).to.throw();
     });
 
     it ('defines properties that are passed without passing an existing object, and seals them', () => {
@@ -433,100 +436,95 @@ describe("Object - defineSealed", () => {
             },
         });
 
-        expect(obj.a).toBeDefined();
-        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).toBe(undefined);
-        expect(typeof Object.getOwnPropertyDescriptor(obj, 'a').get).toBe('function');
+        should.exist(obj.a);
+        expect(Object.getOwnPropertyDescriptor(obj, 'a').set).to.eql(undefined);
+        assert.typeOf(Object.getOwnPropertyDescriptor(obj, 'a').get, 'function');
 
-        expect(Object.isSealed(obj)).toEqual(true);
+        expect(Object.isSealed(obj)).to.eql(true);
         expect(function () {
             obj.a = 9999;
-        }).toThrowError();
+        }).to.throw();
         expect(function () {
             Object.defineProperty(obj, {
                 x: {
                     get: () => 9999,
                 },
             });
-        }).toThrowError();
+        }).to.throw();
     });
 
     it ('throws a type error when passed something else than the expected parameters', () => {
         expect(function() {
             defineSealed(false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
 
         expect(function() {
             defineSealed({}, false);
-        }).toThrowError(TypeError);
+        }).to.throw(TypeError);
     });
 });
 
 describe("Object - isNotEmptyObject", () => {
     it ('not see a string as a not empty object', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a not empty object', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 
     it ('not see a boolean as a not empty object', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 
     it ('not see a regex as a not empty object', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 
     it ('see an object as an object', () => {
-        expect(isNotEmptyObject({bar:'foo'})).toEqual(true);
+        expect(isNotEmptyObject({bar:'foo'})).to.eql(true);
 
         expect(isNotEmptyObject(Object.defineProperties(Object.create(null), {
             'hi': {
                 enumerable: true,
                 get: () => 'there',
             }
-        }))).toEqual(true);
+        }))).to.eql(true);
     });
 
     it ('see an empty object as an empty object', () => {
-        expect(isNotEmptyObject(Object.create(null))).toEqual(false);
-        expect(isNotEmptyObject(new Object())).toEqual(false);
-        expect(isNotEmptyObject(Object.create([]))).toEqual(false);
+        expect(isNotEmptyObject(Object.create(null))).to.eql(false);
+        expect(isNotEmptyObject(new Object())).to.eql(false);
+        expect(isNotEmptyObject(Object.create([]))).to.eql(false);
         expect(isNotEmptyObject(Object.defineProperties(Object.create(null), {
             'hi': {
                 enumerable: false,
                 get: () => 'there',
             }
-        }))).toEqual(false);
+        }))).to.eql(false);
     });
 
     it ('not see a nullable as a not empty object', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 
     it ('not see a date as a not empty object', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 
     it ('not see an array as a not empty object', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 
     it ('not see a function as a not empty object', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
-    });
-
-    it ('not see formdata as a not empty object', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isNotEmptyObject(el)).toEqual(false);
+        for (let el of vals) expect(isNotEmptyObject(el)).to.eql(false);
     });
 });

package/test/src/regexp.test.js

@@ -10,58 +10,61 @@ 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("RegExp - isRegExp", () => {
     it ('not see a string as a regex', () => {
         let vals = fnStringValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a regex', () => {
         let vals = fnNumericValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a boolean as a regex', () => {
         let vals = fnBooleanValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('see a regex as a regex', () => {
         let vals = fnRegexValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(true);
+        for (let el of vals) expect(isRegExp(el)).to.eql(true);
     });
 
     it ('not see an object as a regex', () => {
         let vals = fnObjectValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a nullable as a regex', () => {
         let vals = fnNullables();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a date as a regex', () => {
         let vals = fnDateValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see an array as a regex', () => {
         let vals = fnArrayValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a function as a regex', () => {
         let vals = fnFunctionValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
-    });
-
-    it ('not see formdata as a regex', () => {
-        let vals = fnFormDataValues();
-        for (let el of vals) expect(isRegExp(el)).toEqual(false);
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 });