@valkyriestudios/utils 4.0.0 → 5.0.0

package/test/src/regexp.test.js

@@ -1,74 +1,70 @@
 'use strict';
 
 import isRegExp from '../../src/regexp/is';
+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("RegExp - isRegExp", () => {
     it ('not see a string as a regex', () => {
-        expect(isRegExp('foo')).toEqual(false);
-        expect(isRegExp(new String('bar'))).toEqual(false);
+        let vals = fnStringValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a numeric value as a regex', () => {
-        expect(isRegExp(1)).toEqual(false);
-        expect(isRegExp(NaN)).toEqual(false);
-        expect(isRegExp(0.000001)).toEqual(false);
-        expect(isRegExp(8e10)).toEqual(false);
-        expect(isRegExp(Math.PI)).toEqual(false);
-        expect(isRegExp(new Number(1.12345))).toEqual(false);
-        expect(isRegExp(new Number(Number.EPSILON))).toEqual(false);
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a boolean as a regex', () => {
-        expect(isRegExp(true)).toEqual(false);
-        expect(isRegExp(false)).toEqual(false);
-        expect(isRegExp(Boolean(true))).toEqual(false);
-        expect(isRegExp(Boolean(false))).toEqual(false);
-        expect(isRegExp(Boolean('foo'))).toEqual(false);
-        expect(isRegExp(new Boolean(false))).toEqual(false);
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('see a regex as a regex', () => {
-        expect(isRegExp(/abcdefg/i)).toEqual(true);
-        expect(isRegExp(new RegExp('\\w+'))).toEqual(true);
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(true);
     });
 
     it ('not see an object as a regex', () => {
-        expect(isRegExp({bar:'foo'})).toEqual(false);
-        expect(isRegExp(new Object())).toEqual(false);
-        expect(isRegExp(Object.create(null))).toEqual(false);
-        expect(isRegExp(Object.create([]))).toEqual(false);
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
-    it ('not see a null as a regex', () => {
-        expect(isRegExp(null)).toEqual(false);
+    it ('not see a nullable as a regex', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a date as a regex', () => {
-        expect(isRegExp(new Date())).toEqual(false);
-        expect(isRegExp(Date.now())).toEqual(false);
-    });
-
-    it ('not see an undefined as a regex', () => {
-        expect(isRegExp(undefined)).toEqual(false);
+        let vals = fnDateValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see an array as a regex', () => {
-        expect(isRegExp([0, 1, 2])).toEqual(false);
-        expect(isRegExp(new Array(1, 2, 3))).toEqual(false);
-        expect(isRegExp(new Array(5))).toEqual(false);
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 
     it ('not see a function as a regex', () => {
-        function testFunction () {}
-
-        const testArrowFunction = () => {};
-
-        expect(isRegExp(testFunction)).toEqual(false);
-        expect(isRegExp(testArrowFunction)).toEqual(false);
-    });
-
-    it ('not see formdata as a regex', () => {
-        let fdata = new FormData();
-        expect(isRegExp(fdata)).toEqual(false);
+        let vals = fnFunctionValues();
+        for (let el of vals) expect(isRegExp(el)).to.eql(false);
     });
 });

package/test/src/string.test.js

@@ -1,74 +1,250 @@
 'use strict';
 
-import isString from '../../src/string/is';
+import isString         from '../../src/string/is';
+import isStringBetween  from '../../src/string/isBetween';
+import isNotEmptyString from '../../src/string/isNotEmpty';
+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("String - isString", () => {
     it ('see a string as a string', () => {
-        expect(isString('foo')).toEqual(true);
-        expect(isString(new String('bar'))).toEqual(true);
+        let vals = fnStringValues();
+        for (let el of vals) expect(isString(el)).to.eql(true);
     });
 
     it ('not see a numeric value as a string', () => {
-        expect(isString(1)).toEqual(false);
-        expect(isString(NaN)).toEqual(false);
-        expect(isString(0.000001)).toEqual(false);
-        expect(isString(8e10)).toEqual(false);
-        expect(isString(Math.PI)).toEqual(false);
-        expect(isString(new Number(1.12345))).toEqual(false);
-        expect(isString(new Number(Number.EPSILON))).toEqual(false);
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isString(el)).to.eql(false);
     });
 
     it ('not see a boolean as a string', () => {
-        expect(isString(true)).toEqual(false);
-        expect(isString(false)).toEqual(false);
-        expect(isString(Boolean(true))).toEqual(false);
-        expect(isString(Boolean(false))).toEqual(false);
-        expect(isString(Boolean('foo'))).toEqual(false);
-        expect(isString(new Boolean(false))).toEqual(false);
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isString(el)).to.eql(false);
     });
 
     it ('not see a regex as a string', () => {
-        expect(isString(/abcdefg/i)).toEqual(false);
-        expect(isString(new RegExp('\\w+'))).toEqual(false);
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isString(el)).to.eql(false);
     });
 
     it ('not see an object as a string', () => {
-        expect(isString({bar:'foo'})).toEqual(false);
-        expect(isString(new Object())).toEqual(false);
-        expect(isString(Object.create(null))).toEqual(false);
-        expect(isString(Object.create([]))).toEqual(false);
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isString(el)).to.eql(false);
     });
 
-    it ('not see a null as a string', () => {
-        expect(isString(null)).toEqual(false);
+    it ('not see a nullable as a string', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isString(el)).to.eql(false);
     });
 
     it ('not see a date as a string', () => {
-        expect(isString(new Date())).toEqual(false);
-        expect(isString(Date.now())).toEqual(false);
+        let vals = fnDateValues();
+        for (let el of vals) expect(isString(el)).to.eql(false);
+    });
+
+    it ('not see an array as a string', () => {
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isString(el)).to.eql(false);
     });
 
-    it ('not see an undefined as a string', () => {
-        expect(isString(undefined)).toEqual(false);
+    it ('not see a function as a string', () => {
+        let vals = fnFunctionValues();
+        for (let el of vals) expect(isString(el)).to.eql(false);
     });
+});
 
-    it ('see an array as a string', () => {
-        expect(isString([0, 1, 2])).toEqual(false);
-        expect(isString(new Array(1, 2, 3))).toEqual(false);
-        expect(isString(new Array(5))).toEqual(false);
+describe("String - isStringBetween", () => {
+    it ('not see a number as a string between', () => {
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
     });
 
-    it ('not see a function as a string', () => {
-        function testFunction () {}
+    it ('treat string values between ranges correctly', () => {
+        let vals = [
+            ['Hi', 1, 5],
+            ['', 0, 1],
+            ['Hello world!', 1, 13],
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], el[1], el[2])).to.eql(true);
+    });
+
+    it ('treat string values between ranges with invalid values incorrectly', () => {
+        let vals = [
+            ['Hi', 1, 5],
+            ['', 0, 1],
+            ['Hello world!', 1, 13],
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], `${el[1]}`, el[2])).to.eql(false);
+        for (let el of vals) expect(isStringBetween(el[0], el[1], `${el[2]}`)).to.eql(false);
+    });
+
+    it ('treat string values below lower bound as false', () => {
+        let vals = [
+            ['Peter', 8, 100],
+            ['', 1, 50],
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], el[1], el[2])).to.eql(false);
+    });
+
+    it ('treat string values at lower bound as true', () => {
+        let vals = [
+            ['Peter', 5, 100],
+            ['', 0, 50],
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], el[1], el[2])).to.eql(true);
+    });
+
+    it ('treat string values above upper bound as false', () => {
+        let vals = [
+            ['Peters Magic Castle', 5, 18],
+            ['foo', 0, 2],
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], el[1], el[2])).to.eql(false);
+    });
+
+    it ('treat string values at upper bound as true', () => {
+        let vals = [
+            ['Peters Magic Castle', 5, 19],
+            ['foo', 0, 3],
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], el[1], el[2])).to.eql(true);
+    });
+
+    it ('returns false when passed a min that is higher than max', () => {
+        expect(isStringBetween('Hello there', 15, 10)).to.eql(false);
+    });
+
+    it ('returns false when passed a min that is equal to max', () => {
+        expect(isStringBetween('Hello there', 9, 9)).to.eql(false);
+    });
+
+    it ('autotrims string values', () => {
+        let vals = [
+            ['   foo   ', 0, 3]
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], el[1], el[2])).to.eql(true);
+    });
+
+    it ('does not autotrim string values when overriding default', () => {
+        let vals = [
+            ['   foo   ', 0, 3]
+        ];
+        for (let el of vals) expect(isStringBetween(el[0], el[1], el[2], false)).to.eql(false);
+    });
+
+    it ('not see a boolean as a string between', () => {
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
+    });
+
+    it ('not see a regex as a string between', () => {
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
+    });
 
-        const testArrowFunction = () => {};
+    it ('not see an object as a string between', () => {
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
+    });
+
+    it ('not see a nullable as a string between', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
+    });
+
+    it ('not see a date as a string between', () => {
+        let vals = fnDateValues();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
+    });
+
+    it ('not see an array as a string between', () => {
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
+    });
+
+    it ('not see a function as a string between', () => {
+        let vals = fnFunctionValues();
+        for (let el of vals) expect(isStringBetween(el, 0, 1000)).to.eql(false);
+    });
+});
+
+describe("String - isNotEmptyString", () => {
+    it ('see a non-empty string as a not empty string', () => {
+        let vals = fnStringValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(true);
+    });
+
+    it ('see an empty string as an empty string', () => {
+        expect(isNotEmptyString('')).to.eql(false);
+    });
+
+    it ('sees a string with only spaces as an empty string by default', () => {
+        expect(isNotEmptyString(' ')).to.eql(false);
+        expect(isNotEmptyString('   ')).to.eql(false);
+        expect(isNotEmptyString('               ')).to.eql(false);
+    });
+
+    it ('allows seeing a string with only spaces as a non-empty string by passing trimmed=false', () => {
+        expect(isNotEmptyString(' ', false)).to.eql(true);
+        expect(isNotEmptyString('   ', false)).to.eql(true);
+        expect(isNotEmptyString('               ', false)).to.eql(true);
+    });
+
+    it ('not see a numeric value as a not empty string', () => {
+        let vals = fnNumericValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
+    });
+
+    it ('not see a boolean as a not empty string', () => {
+        let vals = fnBooleanValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
+    });
+
+    it ('not see a regex as a not empty string', () => {
+        let vals = fnRegexValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
+    });
+
+    it ('not see an object as a not empty string', () => {
+        let vals = fnObjectValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
+    });
+
+    it ('not see a nullable as a not empty string', () => {
+        let vals = fnNullables();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
+    });
+
+    it ('not see a date as a not empty string', () => {
+        let vals = fnDateValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
+    });
 
-        expect(isString(testFunction)).toEqual(false);
-        expect(isString(testArrowFunction)).toEqual(false);
+    it ('not see an array as a not empty string', () => {
+        let vals = fnArrayValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
     });
 
-    it ('not see formdata as a string', () => {
-        let fdata = new FormData();
-        expect(isString(fdata)).toEqual(false);
+    it ('not see a function as a not empty string', () => {
+        let vals = fnFunctionValues();
+        for (let el of vals) expect(isNotEmptyString(el)).to.eql(false);
     });
 });

package/formdata/is.js

@@ -1,9 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-});
-
-exports.default = function (val) {
-    return typeof FormData !== 'undefined' && val instanceof FormData;
-};

package/karma.conf.js

@@ -1,64 +0,0 @@
-const path = require('path');
-
-module.exports = function(config) {
-    config.set({
-        basePath: './',
-        frameworks: ['jasmine'],
-        files: [
-            {pattern: 'test/test_index.js'},
-        ],
-        exclude: [],
-        preprocessors: {
-            'test/test_index.js': ['webpack'],
-            'src/**/*.js': ['coverage'],
-        },
-        webpack: {
-            mode: 'development',
-            module: {
-                rules: [
-                    // instrument only testing sources with Istanbul
-                    {
-                        test: /\.js$/,
-                        use: {
-                            loader: 'istanbul-instrumenter-loader',
-                            options: { esModules: true },
-                        },
-                        include: path.resolve('src/')
-                    }
-                ]
-            }
-        },
-        webpackMiddleware: {
-            noInfo: true,
-            stats: {
-                chunks: false,
-            },
-        },
-        client: {
-            jasmine: {
-                random: false,
-            },
-        },
-        reporters: ['spec', 'coverage'],
-        port: 9876,
-        colors: true,
-        logLevel: config.LOG_INFO,
-        autoWatch: true,
-        browsers: ['ChromeHeadless'],
-        singleRun: true,
-        coverageReporter: {
-            reporters: [{type: 'lcov'}],
-        },
-        customLaunchers: {
-            ChromeHeadless: {
-                base: 'Chrome',
-                flags: [
-                    '--no-sandbox',
-                    '--headless',
-                    '--disable-gpu',
-                    '--remote-debugging-port=9222',
-                ],
-            },
-        },
-    });
-};

package/test/src/formdata.test.js

@@ -1,74 +0,0 @@
-'use strict';
-
-import isFormData from '../../src/formdata/is';
-
-describe("FormData - isFormData", () => {
-    it ('not see a string as formdata', () => {
-        expect(isFormData('foo')).toEqual(false);
-        expect(isFormData(new String('bar'))).toEqual(false);
-    });
-
-    it ('not see a numeric value as formdata', () => {
-        expect(isFormData(1)).toEqual(false);
-        expect(isFormData(NaN)).toEqual(false);
-        expect(isFormData(0.000001)).toEqual(false);
-        expect(isFormData(8e10)).toEqual(false);
-        expect(isFormData(Math.PI)).toEqual(false);
-        expect(isFormData(new Number(1.12345))).toEqual(false);
-        expect(isFormData(new Number(Number.EPSILON))).toEqual(false);
-    });
-
-    it ('not see a boolean as formdata', () => {
-        expect(isFormData(true)).toEqual(false);
-        expect(isFormData(false)).toEqual(false);
-        expect(isFormData(Boolean(true))).toEqual(false);
-        expect(isFormData(Boolean(false))).toEqual(false);
-        expect(isFormData(Boolean('foo'))).toEqual(false);
-        expect(isFormData(new Boolean(false))).toEqual(false);
-    });
-
-    it ('not see a regex as formdata', () => {
-        expect(isFormData(/abcdefg/i)).toEqual(false);
-        expect(isFormData(new RegExp('\\w+'))).toEqual(false);
-    });
-
-    it ('not see an object as formdata', () => {
-        expect(isFormData({bar:'foo'})).toEqual(false);
-        expect(isFormData(new Object())).toEqual(false);
-        expect(isFormData(Object.create(null))).toEqual(false);
-        expect(isFormData(Object.create([]))).toEqual(false);
-    });
-
-    it ('not see a null as formdata', () => {
-        expect(isFormData(null)).toEqual(false);
-    });
-
-    it ('not see a date as formdata', () => {
-        expect(isFormData(new Date())).toEqual(false);
-        expect(isFormData(Date.now())).toEqual(false);
-    });
-
-    it ('not see an undefined as formdata', () => {
-        expect(isFormData(undefined)).toEqual(false);
-    });
-
-    it ('not see an array as formdata', () => {
-        expect(isFormData([0, 1, 2])).toEqual(false);
-        expect(isFormData(new Array(1, 2, 3))).toEqual(false);
-        expect(isFormData(new Array(5))).toEqual(false);
-    });
-
-    it ('not see a function as formdata', () => {
-        function testFunction () {}
-
-        const testArrowFunction = () => {};
-
-        expect(isFormData(testFunction)).toEqual(false);
-        expect(isFormData(testArrowFunction)).toEqual(false);
-    });
-
-    it ('see formdata as formdata', () => {
-        let fdata = new FormData();
-        expect(isFormData(fdata)).toEqual(true);
-    });
-});

package/test/test_index.js

@@ -1,2 +0,0 @@
-var testsContext = require.context(".", true, /\.test\.js$/);
-testsContext.keys().forEach(testsContext);