type-enforcer-test-helper 1.3.10 → 2.0.0-alpha.0

package/README.md

@@ -1,18 +1,12 @@
 # Type Enforcer Test Helper
 
 > Test data and helper functions for type-enforcer and addons
->
-> [![npm][npm]][npm-url]
-[![deps][deps]][deps-url]
-[![size][size]][size-url]
-[![vulnerabilities][vulnerabilities]][vulnerabilities-url]
-[![license][license]][license-url]
 
 <br><a name="Installation"></a>
 
 ## Installation
 ```
-npm install type-enforcer-test-helper
+npm install type-enforcer-test-helper --save-dev
 ```
 
 <br><a name="About"></a>
@@ -23,158 +17,10 @@ This library consists of two things. First is a data set of variations of differ
 
 <br>
 
-## Classes
-
-<dl>
-<dt><a href="docs/TestClass.md">TestClass</a></dt>
-<dd><p>A simple class for testing things like instanceof</p>
-</dd>
-</dl>
-
-<br>
-
-## Constants
-
-<dl>
-<dt><a href="docs/testTypes.md">testTypes</a> : <code>Array</code></dt>
-<dd><p>An array of all the test type objects (arrayData, booleanData, etc.)</p>
-</dd>
-<dt><a href="docs/arrayData.md">arrayData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Arrays</p>
-</dd>
-<dt><a href="docs/booleanData.md">booleanData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Booleans</p>
-</dd>
-<dt><a href="docs/dateData.md">dateData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Dates</p>
-</dd>
-<dt><a href="docs/functionData.md">functionData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Functions</p>
-</dd>
-<dt><a href="docs/instanceData.md">instanceData</a> : <code>object</code></dt>
-<dd><p>A data set for testing instanceOf</p>
-</dd>
-<dt><a href="docs/integerData.md">integerData</a> : <code>object</code></dt>
-<dd><p>A data set for testing integers</p>
-</dd>
-<dt><a href="docs/jsonData.md">jsonData</a> : <code>object</code></dt>
-<dd><p>A data set for testing JSON</p>
-</dd>
-<dt><a href="docs/floatData.md">floatData</a> : <code>object</code></dt>
-<dd><p>A data set for testing integers</p>
-</dd>
-<dt><a href="docs/numberData.md">numberData</a> : <code>object</code></dt>
-<dd><p>A data set for testing numbers</p>
-</dd>
-<dt><a href="docs/mapData.md">mapData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Maps</p>
-</dd>
-<dt><a href="docs/objectData.md">objectData</a> : <code>object</code></dt>
-<dd><p>A data set for testing plain Objects</p>
-</dd>
-<dt><a href="docs/promiseData.md">promiseData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Promises</p>
-</dd>
-<dt><a href="docs/regExpData.md">regExpData</a> : <code>object</code></dt>
-<dd><p>A data set for testing RegExps</p>
-</dd>
-<dt><a href="docs/setData.md">setData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Sets</p>
-</dd>
-<dt><a href="docs/stringData.md">stringData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Strings</p>
-</dd>
-<dt><a href="docs/symbolData.md">symbolData</a> : <code>object</code></dt>
-<dd><p>A data set for testing Symbols</p>
-</dd>
-<dt><a href="docs/weakMapData.md">weakMapData</a> : <code>object</code></dt>
-<dd><p>A data set for testing WeakMaps</p>
-</dd>
-<dt><a href="docs/weakSetData.md">weakSetData</a> : <code>object</code></dt>
-<dd><p>A data set for testing WeakSets</p>
-</dd>
-<dt><a href="docs/testValues.md">testValues</a> : <code>Array</code></dt>
-<dd><p>A concatenated array of all the &quot;valid&quot; arrays.</p>
-</dd>
-<dt><a href="docs/validArrays.md">validArrays</a> : <code>Array</code></dt>
-<dd><p>Arrays instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validBooleans.md">validBooleans</a> : <code>Array</code></dt>
-<dd><p>Booleans instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validDates.md">validDates</a> : <code>Array</code></dt>
-<dd><p>Dates instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validFunctions.md">validFunctions</a> : <code>Array</code></dt>
-<dd><p>Functions instantiated in different ways.</p>
-</dd>
-<dt><a href="docs/validInstances.md">validInstances</a> : <code>Array</code></dt>
-<dd><p>Different instances of TestClass with different values.</p>
-</dd>
-<dt><a href="docs/validIntegers.md">validIntegers</a> : <code>Array</code></dt>
-<dd><p>Integers instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validFloats.md">validFloats</a> : <code>Array</code></dt>
-<dd><p>Floats instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validInfinities.md">validInfinities</a> : <code>Array</code></dt>
-<dd><p>Infinity and -Infinity</p>
-</dd>
-<dt><a href="docs/validMaps.md">validMaps</a> : <code>Array</code></dt>
-<dd><p>An empty Map and a Map with data.</p>
-</dd>
-<dt><a href="docs/validObjects.md">validObjects</a> : <code>Array</code></dt>
-<dd><p>Plain objects instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validPromises.md">validPromises</a> : <code>Array</code></dt>
-<dd><p>A normal Promise and Promise.all.</p>
-</dd>
-<dt><a href="docs/validRegExps.md">validRegExps</a> : <code>Array</code></dt>
-<dd><p>RegExps instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validSets.md">validSets</a> : <code>Array</code></dt>
-<dd><p>An empty Set and a Set with data.</p>
-</dd>
-<dt><a href="docs/validStrings.md">validStrings</a> : <code>Array</code></dt>
-<dd><p>Strings instantiated in different ways or with different values.</p>
-</dd>
-<dt><a href="docs/validSymbols.md">validSymbols</a> : <code>Array</code></dt>
-<dd><p>A Symbol with a label and one without.</p>
-</dd>
-<dt><a href="docs/validWeakMaps.md">validWeakMaps</a> : <code>Array</code></dt>
-<dd><p>An empty WeakMap and a WeakMap with data.</p>
-</dd>
-<dt><a href="docs/validWeakSets.md">validWeakSets</a> : <code>Array</code></dt>
-<dd><p>An empty WeakSet and a WeakSet with data.</p>
-</dd>
-<dt><a href="docs/validNots.md">validNots</a> : <code>Array</code></dt>
-<dd><p>Undefined, null, and NaN</p>
-</dd>
-</dl>
-
-<br>
-
-## Functions
-
-<dl>
-<dt><a href="docs/multiTest.md">multiTest(settings)</a></dt>
-<dd><p>Run multiple identical tests over a set of data.</p>
-</dd>
-<dt><a href="docs/testCheck.md">testCheck(data, check, is)</a></dt>
-<dd><p>Test a type-enforcer check function (isArray, isBoolean, etc.).</p>
-</dd>
-<dt><a href="docs/testEnforce.md">testEnforce(data, enforcer, enforce, coercer)</a></dt>
-<dd><p>Test an enforce function (enforceArray, enforceBoolean, etc.).</p>
-</dd>
-<dt><a href="docs/testMethod.md">testMethod(settings, thisMethod, method)</a></dt>
-<dd><p>Test a chainable method function (methodArray, methodBoolean, etc.).</p>
-</dd>
-</dl>
+- [Documentation](https://github.com/DarrenPaulWright/type-enforcer-test-helper/blob/main/docs/README.md)
 
 [npm]: https://img.shields.io/npm/v/type-enforcer-test-helper.svg
 [npm-url]: https://npmjs.com/package/type-enforcer-test-helper
-[deps]: https://david-dm.org/DarrenPaulWright/type-enforcer-test-helper.svg
-[deps-url]: https://david-dm.org/DarrenPaulWright/type-enforcer-test-helper
 [size]: https://packagephobia.now.sh/badge?p&#x3D;type-enforcer-test-helper
 [size-url]: https://packagephobia.now.sh/result?p&#x3D;type-enforcer-test-helper
 [vulnerabilities]: https://snyk.io/test/github/DarrenPaulWright/type-enforcer-test-helper/badge.svg?targetFile&#x3D;package.json

package/dist/js/index.js

@@ -0,0 +1,7 @@
+export * from './src/data/testValues.js';
+export { default as TestClass } from './src/data/TestClass.js';
+export * from './src/data/testData.js';
+export { default as multiTest } from './src/multiTest.js';
+export { default as testCheck } from './src/testCheck.js';
+export { default as testEnforce } from './src/testEnforce.js';
+export { default as testMethod } from './src/testMethod.js';

package/dist/js/src/data/TestClass.js

@@ -0,0 +1,12 @@
+export default class TestClass {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+}

package/dist/js/src/data/coercible.js

@@ -0,0 +1,81 @@
+export const coerceArrayTrue = ['["test"]', '[]'];
+export const coerceInfinity = [
+    'Infinity',
+    '-Infinity'
+];
+export const coerceIntegerTrue = [
+    '0',
+    '1',
+    '1.00',
+    '1E2',
+    '1E02',
+    '1E+02',
+    '-1',
+    '-1.00',
+    '-1E2',
+    '-1E02',
+    '-1E+02',
+    '-0',
+    '-0.0',
+    '+0',
+    '+0.0',
+    '0.00',
+    '0x0',
+    '0xffffffff',
+    '0xffffffffffffffff',
+    '0xabad1dea',
+    '01000',
+    '08',
+    '09'
+];
+export const coerceFloatTrue = [
+    '3.2',
+    '10.5'
+];
+export const coerceNumberFalse = [
+    '$1.00',
+    '1/2',
+    '-$1.00',
+    '-1/2',
+    '1/0',
+    '0/0',
+    '-2147483648/-1',
+    '-9223372036854775808/-1',
+    '0..0',
+    '.',
+    '0.0.0',
+    '0,00',
+    '0,,0',
+    ',',
+    '0,0,0',
+    '0.0/0',
+    '1.0/0.0',
+    '0.0/0.0',
+    '1,0/0,0',
+    '0,0/0,0',
+    '--1',
+    '-',
+    '-.',
+    '-,',
+    'NaN',
+    'INF',
+    '1#INF',
+    '-1#IND',
+    '1#QNAN',
+    '1#SNAN',
+    '1#IND',
+    '1,000.00',
+    '1 000.00',
+    '1\'000.00',
+    '1,000,000.00',
+    '1 000 000.00',
+    '1\'000\'000.00',
+    '1.000,00',
+    '1 000,00',
+    '1\'000,00',
+    '1.000.000,00',
+    '1 000 000,00',
+    '1\'000\'000,00',
+    NaN
+];
+export const coerceObjectTrue = ['{}', '{"test":"test"}'];

package/dist/js/src/data/testData.js

@@ -0,0 +1,168 @@
+import difference from '../utility/difference.js';
+import { coerceArrayTrue, coerceFloatTrue, coerceInfinity, coerceIntegerTrue, coerceNumberFalse, coerceObjectTrue } from './coercible.js';
+import TestClass from './TestClass.js';
+import { testValues, validArrays, validBooleans, validDates, validFloats, validFunctions, validInfinities, validInstances, validIntegers, validMaps, validObjects, validPromises, validRegExps, validSets, validStrings, validSymbols, validWeakMaps, validWeakSets } from './testValues.js';
+export const arrayData = {
+    value: Array,
+    name: 'array',
+    true: validArrays,
+    false: difference(testValues, validArrays),
+    coerceTrue: coerceArrayTrue,
+    coerceFalse: difference(testValues, validArrays)
+};
+export const booleanData = {
+    value: Boolean,
+    name: 'boolean',
+    true: validBooleans,
+    false: difference(testValues, validBooleans),
+    coerceTrue: difference(testValues, validBooleans),
+    coerceFalse: []
+};
+export const dateData = {
+    value: Date,
+    name: 'date',
+    true: validDates,
+    false: difference(testValues, validDates),
+    coerceTrue: ['10/12/1980', 'January 8, 2014'],
+    coerceFalse: difference(testValues, validDates, validArrays, validFloats, validIntegers, validRegExps)
+};
+export const functionData = {
+    value: Function,
+    name: 'function',
+    true: validFunctions,
+    false: difference(testValues, validFunctions),
+    coerceTrue: [],
+    coerceFalse: difference(testValues, validFunctions)
+};
+export const instanceData = {
+    value: TestClass,
+    name: 'instanceOf',
+    true: validInstances,
+    false: difference(testValues, validInstances),
+    coerceTrue: [],
+    coerceFalse: []
+};
+export const integerData = {
+    name: 'integer',
+    skip: ['number', 'float'],
+    true: validIntegers,
+    false: difference(testValues, validIntegers, validInfinities),
+    coerceTrue: coerceIntegerTrue,
+    coerceFalse: coerceNumberFalse.concat(coerceFloatTrue, coerceInfinity)
+};
+export const jsonData = {
+    name: 'json',
+    true: coerceObjectTrue.concat(coerceArrayTrue, JSON.stringify(testValues)),
+    false: ['json'].concat(validDates, validFunctions, validObjects, validRegExps),
+    coerceTrue: [],
+    coerceFalse: []
+};
+export const floatData = {
+    name: 'float',
+    skip: ['number', 'integer'],
+    true: validFloats,
+    false: difference(testValues, validFloats, validIntegers, validInfinities),
+    coerceTrue: coerceIntegerTrue.concat(coerceFloatTrue),
+    coerceFalse: coerceNumberFalse.concat(coerceInfinity)
+};
+export const numberData = {
+    value: Number,
+    name: 'number',
+    skip: ['integer', 'float'],
+    true: validFloats.concat(validIntegers, validInfinities),
+    false: difference(testValues, validFloats, validIntegers, validInfinities, [NaN]),
+    coerceTrue: coerceIntegerTrue.concat(coerceInfinity),
+    coerceFalse: coerceNumberFalse
+};
+export const mapData = {
+    value: Map,
+    name: 'map',
+    true: validMaps,
+    false: difference(testValues, validMaps),
+    coerceTrue: coerceObjectTrue.concat(validObjects, [[[TestClass, 2],
+            [TestClass, 'test']], '[["test 1", 2], ["test 2", "test"]]']),
+    coerceFalse: difference(testValues, validMaps, validObjects, validArrays).concat(['test'])
+};
+export const objectData = {
+    value: Object,
+    name: 'object',
+    true: validObjects,
+    false: [null, undefined, true, false],
+    coerceTrue: coerceObjectTrue,
+    coerceFalse: validStrings
+};
+export const promiseData = {
+    value: Promise,
+    name: 'promise',
+    true: validPromises,
+    false: difference(testValues, validPromises),
+    coerceTrue: validFunctions,
+    coerceFalse: difference(testValues, validFunctions, validPromises)
+};
+export const regExpData = {
+    value: RegExp,
+    name: 'regExp',
+    true: validRegExps,
+    false: difference(testValues, validRegExps),
+    coerceTrue: ['test', '/[a-z]+/', '/[a-z]+/gi'],
+    coerceFalse: difference(testValues, validStrings, validRegExps)
+};
+export const setData = {
+    value: Set,
+    name: 'set',
+    true: validSets,
+    false: difference(testValues, validSets),
+    coerceTrue: validArrays.concat(['[]', '[1, 2]']),
+    coerceFalse: difference(testValues, validSets, validArrays)
+};
+export const stringData = {
+    value: String,
+    name: 'string',
+    true: validStrings,
+    false: difference(testValues, validStrings),
+    coerceTrue: difference(testValues, validStrings, [null, undefined]),
+    coerceFalse: [null, undefined]
+};
+export const symbolData = {
+    value: Symbol,
+    name: 'symbol',
+    true: validSymbols,
+    false: difference(testValues, validSymbols),
+    coerceTrue: stringData.coerceTrue,
+    coerceFalse: stringData.coerceFalse
+};
+export const weakMapData = {
+    value: WeakMap,
+    name: 'weakMap',
+    true: validWeakMaps,
+    false: difference(testValues, validWeakMaps),
+    coerceTrue: [[[TestClass, 2], [TestClass, 'test']]],
+    coerceFalse: difference(testValues, validWeakMaps, validArrays).concat(['test'])
+};
+export const weakSetData = {
+    value: WeakSet,
+    name: 'weakSet',
+    true: validWeakSets,
+    false: difference(testValues, validWeakSets),
+    coerceTrue: [validInstances],
+    coerceFalse: difference(testValues, validWeakSets, validArrays)
+};
+export const testTypes = [
+    arrayData,
+    booleanData,
+    dateData,
+    functionData,
+    instanceData,
+    integerData,
+    floatData,
+    numberData,
+    mapData,
+    objectData,
+    promiseData,
+    regExpData,
+    setData,
+    stringData,
+    symbolData,
+    weakMapData,
+    weakSetData
+];

package/dist/js/src/data/testValues.js

@@ -0,0 +1,116 @@
+import TestClass from './TestClass.js';
+const arrayReference = Array(3);
+export const validArrays = [
+    [1],
+    [2],
+    [],
+    new Array(),
+    new Array(12),
+    Array(),
+    arrayReference
+];
+const booleanReference = Boolean();
+export const validBooleans = [
+    true,
+    false,
+    new Boolean(true),
+    Boolean(1),
+    booleanReference
+];
+const dateReference = new Date();
+export const validDates = [
+    dateReference,
+    new Date('01/15/2010')
+];
+const namedFunctionExpression = function () {
+};
+export const validFunctions = [
+    namedFunctionExpression,
+    function namedFunctionDeclaration() {
+    },
+    function () {
+    },
+    () => {
+    }
+];
+const classReference = new TestClass(1);
+export const validInstances = [
+    classReference,
+    new TestClass(1),
+    new TestClass(2)
+];
+const integerReference = Number(11);
+export const validIntegers = [
+    1,
+    5,
+    3773586621232700,
+    new Number(42),
+    integerReference
+];
+const floatReference = Number(11.3);
+export const validFloats = [
+    1.3,
+    2.5,
+    -10.00000001,
+    3.14159,
+    new Number(42.2),
+    floatReference
+];
+const infinityReference = Infinity;
+export const validInfinities = [
+    infinityReference,
+    -Infinity
+];
+const mapReference = new Map().set('test', 12);
+export const validMaps = [
+    new Map(),
+    mapReference
+];
+const objectReference = Object();
+export const validObjects = [
+    {},
+    { test1: 1 },
+    new Object(),
+    objectReference
+];
+const promiseReference = new Promise((resolve) => resolve());
+export const validPromises = [
+    promiseReference,
+    new Promise((resolve) => resolve()),
+    Promise.all([promiseReference])
+];
+const regExpReference = RegExp('');
+export const validRegExps = [
+    /asdf/g,
+    new RegExp('test 2'),
+    regExpReference
+];
+const setReference = new Set([1, 2]);
+export const validSets = [
+    new Set(),
+    setReference
+];
+const stringReference = String('test3');
+export const validStrings = [
+    'test',
+    '',
+    new String('test2'),
+    stringReference
+];
+const symbolReference = Symbol('test');
+export const validSymbols = [
+    Symbol(),
+    symbolReference
+];
+const weakMapReference = new WeakMap().set({}, 12);
+export const validWeakMaps = [
+    new WeakMap(),
+    weakMapReference
+];
+const weakSetReference = new WeakSet([new TestClass()]);
+export const validWeakSets = [
+    new WeakSet(),
+    weakSetReference
+];
+export const validNots = [undefined, null, NaN];
+export const testValues = validNots.concat(validArrays, validBooleans, validDates, validFunctions, validInstances, validIntegers, validFloats, validInfinities, validMaps, validObjects, validPromises, validRegExps, validSets, validStrings, validWeakMaps, validWeakSets);

package/dist/js/src/multiTest.js

@@ -0,0 +1,116 @@
+import displayValue from 'display-value';
+import { forOwn, mix } from 'object-agent';
+import { it, assert } from 'hippogriff';
+const getMessage = (settings, assertion) => {
+    if (settings.message) {
+        return settings.message;
+    }
+    if (assertion === 'true') {
+        return (input) => `should return true for ${displayValue(input)}`;
+    }
+    if (assertion === 'false') {
+        return (input) => `should return false for ${displayValue(input)}`;
+    }
+    return (input, output) => `should return ${displayValue(output)} when set to ${input}`;
+};
+const doubleValueMessage = ((input1, input2, expected) => {
+    return `should return ${displayValue(expected)} when ${displayValue(input1)} and ${displayValue(input2)} are provided`;
+});
+const isMultiTestSettingsObject = (settings) => {
+    return settings.values && settings.values.constructor === Object;
+};
+export default (settings) => {
+    let assertion = settings.assertion || 'equal';
+    const buildSingleMessage = getMessage(settings, assertion);
+    if (assertion === 'true') {
+        assertion = 'equal';
+        settings.output = true;
+    }
+    else if (assertion === 'false') {
+        assertion = 'equal';
+        settings.output = false;
+    }
+    const buildDoubleMessage = settings.message || doubleValueMessage;
+    const testSingleValue = (input, expected, value, filter) => {
+        if ((!filter) || filter(value)) {
+            it(buildSingleMessage(input, expected), () => {
+                assert[assertion](settings.test(input), expected);
+            });
+        }
+    };
+    const testSingleValueCollection = (input, expected, value, filter) => {
+        if ((!filter) || filter(value)) {
+            it(buildSingleMessage(input, expected), () => {
+                assert[assertion](settings.test(input), expected);
+            });
+        }
+    };
+    const testDoubleValue = (input1, input2, expected, value1, value2) => {
+        if ((!settings.filter) ||
+            settings.filter(value1, value2)) {
+            it(buildDoubleMessage(input1, input2, expected), () => {
+                assert[assertion](settings.test(input1, input2), expected);
+            });
+        }
+    };
+    const testDoubleValueCollection = (input1, input2, expected, value1, value2) => {
+        if ((!settings.filter) ||
+            settings.filter(value1, value2)) {
+            it(buildDoubleMessage(input1, input2, expected), () => {
+                assert[assertion](settings.test(input1, input2), expected);
+            });
+        }
+    };
+    if (isMultiTestSettingsObject(settings)) {
+        forOwn(settings.values, (value, key) => {
+            testSingleValue(key, value, value, settings.filter);
+        });
+    }
+    else if ('eachPair' in settings && settings.eachPair) {
+        mix(settings.values, settings.values2 || settings.values)
+            .forEach((values) => {
+            const value1 = values[0];
+            const value2 = values[1];
+            if ('output' in settings) {
+                if ('inputKey' in settings) {
+                    testDoubleValueCollection(value1[settings.inputKey], value2[settings.inputKey], settings.output, value1, value2);
+                }
+                else {
+                    testDoubleValue(value1, value2, settings.output, value1, value2);
+                }
+            }
+            else if ('inputKey' in settings) {
+                testDoubleValueCollection(value1[settings.inputKey], value2[settings.inputKey], undefined, value1, value2);
+            }
+            else {
+                testDoubleValue(value1, value2, undefined, value1, value2);
+            }
+        });
+    }
+    else {
+        settings.values.forEach((value) => {
+            if ('output' in settings) {
+                if ('inputKey' in settings) {
+                    testSingleValueCollection(value[settings.inputKey], settings.output, value, settings.filter);
+                }
+                else {
+                    testSingleValue(value, settings.output, value, settings.filter);
+                }
+            }
+            else if ('outputKey' in settings) {
+                if ('inputKey' in settings) {
+                    testSingleValueCollection(value[settings.inputKey], value[settings.outputKey], value, settings.filter);
+                }
+                else {
+                    testSingleValue(value, value[settings.outputKey], value, settings.filter);
+                }
+            }
+            else if ('inputKey' in settings) {
+                testSingleValueCollection(value[settings.inputKey], undefined, value, settings.filter);
+            }
+            else {
+                testSingleValue(value, undefined, value, settings.filter);
+            }
+        });
+    }
+};