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

package/src/data/testValues.js

@@ -1,241 +0,0 @@
-import TestClass from './TestClass.js';
-
-/**
- * A concatenated array of all the "valid" arrays.
- *
- * @constant {Array} testValues
- */
-
-/**
- * Arrays instantiated in different ways or with different values.
- *
- * @constant {Array} validArrays
- */
-const arrayReference = Array(3);
-export const validArrays = [
-	[1],
-	[2],
-	[],
-	new Array(),
-	new Array(12),
-	Array(),
-	arrayReference
-];
-
-/**
- * Booleans instantiated in different ways or with different values.
- *
- * @constant {Array} validBooleans
- */
-const booleanReference = Boolean();
-export const validBooleans = [
-	true,
-	false,
-	new Boolean(true), // eslint-disable-line no-new-wrappers
-	Boolean(1),
-	booleanReference
-];
-
-/**
- * Dates instantiated in different ways or with different values.
- *
- * @constant {Array} validDates
- */
-const dateReference = new Date();
-export const validDates = [
-	dateReference,
-	new Date('01/15/2010')
-];
-
-/**
- * Functions instantiated in different ways.
- *
- * @constant {Array} validFunctions
- */
-const namedFunctionExpression = function() {
-};
-export const validFunctions = [
-	namedFunctionExpression,
-	function namedFunctionDeclaration() {
-	},
-	function() {
-	},
-	() => {
-	}
-];
-
-/**
- * Different instances of TestClass with different values.
- *
- * @constant {Array} validInstances
- */
-const classReference = new TestClass(1);
-export const validInstances = [
-	classReference,
-	new TestClass(1),
-	new TestClass(2)
-];
-
-/**
- * Integers instantiated in different ways or with different values.
- *
- * @constant {Array} validIntegers
- */
-const integerReference = Number(11);
-export const validIntegers = [
-	1,
-	5,
-	new Number(42), // eslint-disable-line no-new-wrappers
-	integerReference
-];
-
-/**
- * Floats instantiated in different ways or with different values.
- *
- * @constant {Array} validFloats
- */
-const floatReference = Number(11.3);
-export const validFloats = [
-	1.3,
-	2.5,
-	-10.00000001,
-	3.14159,
-	new Number(42.2), // eslint-disable-line no-new-wrappers
-	floatReference
-];
-
-/**
- * Infinity and -Infinity
- *
- * @constant {Array} validInfinities
- */
-const infinityReference = Infinity;
-export const validInfinities = [
-	infinityReference,
-	-Infinity
-];
-
-/**
- * An empty Map and a Map with data.
- *
- * @constant {Array} validMaps
- */
-const mapReference = new Map().set('test', 12);
-export const validMaps = [
-	new Map(),
-	mapReference
-];
-
-/**
- * Plain objects instantiated in different ways or with different values.
- *
- * @constant {Array} validObjects
- */
-const objectReference = Object();
-export const validObjects = [
-	{},
-	{ test1: 1 },
-	new Object(), // eslint-disable-line no-new-object
-	objectReference
-];
-
-/**
- * A normal Promise and Promise.all.
- *
- * @constant {Array} validPromises
- */
-const promiseReference = new Promise((resolve) => resolve());
-export const validPromises = [
-	promiseReference,
-	new Promise((resolve) => resolve()),
-	Promise.all(promiseReference)
-];
-
-/**
- * RegExps instantiated in different ways or with different values.
- *
- * @constant {Array} validRegExps
- */
-const regExpReference = RegExp(); // eslint-disable-line require-unicode-regexp
-export const validRegExps = [
-	/asdf/g, // eslint-disable-line require-unicode-regexp
-	new RegExp('test 2'), // eslint-disable-line require-unicode-regexp
-	regExpReference
-];
-
-/**
- * An empty Set and a Set with data.
- *
- * @constant {Array} validSets
- */
-const setReference = new Set([1, 2]);
-export const validSets = [
-	new Set(),
-	setReference
-];
-
-/**
- * Strings instantiated in different ways or with different values.
- *
- * @constant {Array} validStrings
- */
-const stringReference = String('test3');
-export const validStrings = [
-	'test',
-	'',
-	new String('test2'), // eslint-disable-line no-new-wrappers
-	stringReference
-];
-
-/**
- * A Symbol with a label and one without.
- *
- * @constant {Array} validSymbols
- */
-const symbolReference = Symbol('test');
-export const validSymbols = [Symbol(), symbolReference];
-
-/**
- * An empty WeakMap and a WeakMap with data.
- *
- * @constant {Array} validWeakMaps
- */
-const weakMapReference = new WeakMap().set({}, 12);
-export const validWeakMaps = [
-	new WeakMap(),
-	weakMapReference
-];
-
-/**
- * An empty WeakSet and a WeakSet with data.
- *
- * @constant {Array} validWeakSets
- */
-const weakSetReference = new WeakSet([new TestClass()]);
-export const validWeakSets = [new WeakSet(), weakSetReference];
-
-/**
- * Undefined, null, and NaN
- *
- * @constant {Array} validNots
- */
-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/src/multiTest.js

@@ -1,125 +0,0 @@
-import displayValue from 'display-value';
-import { forOwn, mix } from 'object-agent';
-import { assert } from 'type-enforcer';
-
-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 }`;
-};
-
-/**
- * Run multiple identical tests over a set of data.
- *
- * @function multiTest
- *
- * @param {object}       settings - Settings object.
- * @param {object | Array} settings.values - The values to run tests against.
- * @param {object | Array} [settings.values2] - Only for eachPair. If not provided, pairs are made within the values array. If provided, pairs are only made with one from each array.
- * @param {Function}     settings.test - The test to run against each value. Provided one or two args (two args if eachPair is true). Each arg is a value from values or values2. Should not call assert, but return a value to be asserted against configured output.
- * @param {Function}     [settings.filter] - Provided one or two args (two args if eachPair is true). Each arg is a value from values or values2. Return a truthy value to run the test, falsey to skip the test.
- * @param {Function}     [settings.message] - Provides two or three params, the input value(s) and the expected output value. Must return a string. It is recommended to use the display-value library on values for readability.
- * @param {string}       [settings.inputKey] - If values is an array of objects, this specifies which key to get the input value from.
- * @param {string}       [settings.outputKey] - If values is an array of objects, this specifies which key to get the expected output value from.
- * @param {unknown}            [settings.output] - The expected output value of all tests.
- * @param {boolean}      [settings.eachPair=false] - Values must be an array, runs tests on every combination of two items from values.
- * @param {string}       [settings.assertion='equal'] - The type-enforcer assert function to run against all tests.
- */
-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 || ((input1, input2, output) => {
-		return `should return ${ displayValue(output) } when ${ displayValue(input1) } and ${ displayValue(input2) } are provided`;
-	});
-
-	const testSingleValue = (input, output, value) => {
-		if ((!settings.filter) || settings.filter(value)) {
-			it(buildSingleMessage(input, output), () => {
-				assert[assertion](settings.test(input), output);
-			});
-		}
-	};
-
-	const testDoubleValue = (input1, input2, output, value1, value2) => {
-		if ((!settings.filter) || settings.filter(value1, value2)) {
-			it(buildDoubleMessage(input1, input2, output), () => {
-				assert[assertion](settings.test(input1, input2), output);
-			});
-		}
-	};
-
-	const testSingleArrayValue = (value) => {
-		if ('output' in settings) {
-			if ('inputKey' in settings) {
-				testSingleValue(value[settings.inputKey], settings.output, value);
-			}
-			else {
-				testSingleValue(value, settings.output, value);
-			}
-		}
-		else if ('outputKey' in settings) {
-			if ('inputKey' in settings) {
-				testSingleValue(value[settings.inputKey], value[settings.outputKey], value);
-			}
-			else {
-				testSingleValue(value, value[settings.outputKey], value);
-			}
-		}
-		else if ('inputKey' in settings) {
-			testSingleValue(value[settings.inputKey], undefined, value);
-		}
-		else {
-			testSingleValue(value, undefined, value);
-		}
-	};
-
-	const testDoubleArrayValue = (value1, value2) => {
-		if ('output' in settings) {
-			if ('inputKey' in settings) {
-				testDoubleValue(value1[settings.inputKey], value2[settings.inputKey], settings.output, value1, value2);
-			}
-			else {
-				testDoubleValue(value1, value2, settings.output, value1, value2);
-			}
-		}
-		else if ('inputKey' in settings) {
-			testDoubleValue(value1[settings.inputKey], value2[settings.inputKey], undefined, value1, value2);
-		}
-		else {
-			testDoubleValue(value1, value2, undefined, value1, value2);
-		}
-	};
-
-	if (settings.values && settings.values.constructor === Object) {
-		forOwn(settings.values, (value, key) => {
-			testSingleValue(key, value, value);
-		});
-	}
-	else if (settings.eachPair) {
-		mix(settings.values, settings.values2 || settings.values)
-			.forEach((values) => {
-				testDoubleArrayValue(values[0], values[1]);
-			});
-	}
-	else {
-		settings.values.forEach(testSingleArrayValue);
-	}
-};

package/src/testCheck.js

@@ -1,67 +0,0 @@
-import { assert } from 'type-enforcer';
-import multiTest from './multiTest.js';
-
-/**
- * Test a type-enforcer check function (isArray, isBoolean, etc.).
- *
- * @function testCheck
- *
- * @param {object} data - A data object (arrayData, booleanData, etc.).
- * @param {Function} check - The function to test.
- * @param {object} is - An object that includes this function.
- */
-export default function(data, check, is) {
-	it('should exist in the exported "is" object', () => {
-		assert.equal(check, is[data.name]);
-	});
-
-	multiTest({
-		values: data.true,
-		test(value) {
-			return check(value);
-		},
-		assertion: 'true'
-	});
-
-	multiTest({
-		values: data.false,
-		test(value) {
-			return check(value);
-		},
-		assertion: 'false'
-	});
-
-	multiTest({
-		values: data.coerceTrue,
-		test(value) {
-			return check(value);
-		},
-		assertion: 'false'
-	});
-
-	describe('coerce', () => {
-		multiTest({
-			values: data.true,
-			test(value) {
-				return check(value, true);
-			},
-			assertion: 'true'
-		});
-
-		multiTest({
-			values: data.coerceTrue,
-			test(value) {
-				return check(value, true);
-			},
-			assertion: 'true'
-		});
-
-		multiTest({
-			values: data.coerceFalse,
-			test(value) {
-				return check(value, true);
-			},
-			assertion: 'false'
-		});
-	});
-}

package/src/testEnforce.js

@@ -1,143 +0,0 @@
-import displayValue from 'display-value';
-import { assert } from 'type-enforcer';
-import TestClass from './data/TestClass.js';
-import { testTypes } from './data/testData.js';
-import multiTest from './multiTest.js';
-
-/**
- * Test an enforce function (enforceArray, enforceBoolean, etc.).
- *
- * @function testEnforce
- *
- * @param {object} data - A data object (arrayData, booleanData, etc.).
- * @param {Function} enforcer - The function to test.
- * @param {object} enforce - An object that includes this function.
- * @param {Function} coercer - A function that does a coercion just like this function.
- */
-export default function(data, enforcer, enforce, coercer) {
-	it('should exist in the exported "enforce" object', () => {
-		assert.equal(enforcer, enforce[data.name]);
-	});
-
-	it(`should return the setter value when a ${data.name} is provided`, () => {
-		let result = null;
-		const value1 = data.true[0];
-		const value2 = data.true[1];
-
-		if (data.extraArg) {
-			result = enforce[data.name](value1, data.extraArg, value2);
-		}
-		else {
-			result = enforce[data.name](value1, value2);
-		}
-
-		assert.is(result, value1);
-		assert.notIs(result, value2);
-	});
-
-	if (coercer === Number) {
-		it('should return the min value when a integer less than the min value is provided', () => {
-			assert.equal(enforce[data.name](-12, 11, false, 0, 5), 0);
-		});
-		it('should return the max value when a integer greater than the max value is provided', () => {
-			assert.equal(enforce[data.name](12, 11, false, 0, 5), 5);
-		});
-	}
-
-	multiTest({
-		values: data.coerceTrue.map((item) => {
-			return {
-				input: item,
-				output: item
-			};
-		}),
-		message(input) {
-			return `should NOT return a coerced ${displayValue(input)} when coerce is false`;
-		},
-		test(value) {
-			return enforce[data.name](value, value, false);
-		},
-		inputKey: 'input',
-		outputKey: 'output',
-		assertion: 'equal'
-	});
-
-	describe('coerce', () => {
-		if (coercer) {
-			multiTest({
-				values: data.coerceTrue.map((item) => {
-					return {
-						input: item,
-						output: coercer(item)
-					};
-				}),
-				message(input) {
-					return `should return a coerced ${displayValue(input)} when coerce is true`;
-				},
-				test(value) {
-					return enforce[data.name](value, value, true);
-				},
-				inputKey: 'input',
-				outputKey: 'output',
-				assertion: 'equal'
-			});
-		}
-
-		multiTest({
-			values: data.coerceFalse,
-			message(input) {
-				return `should return the alt value when ${displayValue(input)} is provided and coerce is true`;
-			},
-			test(value) {
-				return enforce[data.name](value, 'testAlt', true);
-			},
-			output: 'testAlt',
-			assertion: 'equal'
-		});
-	});
-
-	testTypes.forEach((typesData) => {
-		if (typesData.name && !([typesData.name].concat(typesData.skip)
-			.includes(data.name))) {
-			typesData.true.forEach((testItem) => {
-				it(`should return the default value when ${displayValue(testItem)} is provided`, () => {
-					if (data.extraArg) {
-						assert.equal(enforce[data.name](testItem, data.extraArg, data.true[0]), data.true[0]);
-					}
-					else {
-						assert.equal(enforce[data.name](testItem, data.true[0]), data.true[0]);
-					}
-				});
-			});
-		}
-	});
-
-	if (data.name !== 'instanceOf') {
-		it('should return the default value when an instance is provided', () => {
-			if (data.extraArg) {
-				assert.equal(enforce[data.name](new TestClass(), data.extraArg, data.true[0]), data.true[0]);
-			}
-			else {
-				assert.equal(enforce[data.name](new TestClass(), data.true[0]), data.true[0]);
-			}
-		});
-	}
-
-	it('should return the default value when undefined is provided', () => {
-		if (data.extraArg) {
-			assert.equal(enforce[data.name](undefined, data.extraArg, data.true[0]), data.true[0]);
-		}
-		else {
-			assert.equal(enforce[data.name](undefined, data.true[0]), data.true[0]);
-		}
-	});
-
-	it('should return the default value when null is provided', () => {
-		if (data.extraArg) {
-			assert.equal(enforce[data.name](null, data.extraArg, data.true[0]), data.true[0]);
-		}
-		else {
-			assert.equal(enforce[data.name](null, data.true[0]), data.true[0]);
-		}
-	});
-}