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

package/dist/js/src/testCheck.js

@@ -0,0 +1,39 @@
+import { describe, it, assert } from 'hippogriff';
+import multiTest from './multiTest.js';
+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) => check(value),
+        assertion: 'true'
+    });
+    multiTest({
+        values: data.false,
+        test: (value) => check(value),
+        assertion: 'false'
+    });
+    multiTest({
+        values: data.coerceTrue,
+        test: (value) => check(value),
+        assertion: 'false'
+    });
+    describe('coerce', () => {
+        multiTest({
+            values: data.true,
+            test: (value) => check(value, true),
+            assertion: 'true'
+        });
+        multiTest({
+            values: data.coerceTrue,
+            test: (value) => check(value, true),
+            assertion: 'true'
+        });
+        multiTest({
+            values: data.coerceFalse,
+            test: (value) => check(value, true),
+            assertion: 'false'
+        });
+    });
+}

package/dist/js/src/testEnforce.js

@@ -0,0 +1,121 @@
+import displayValue from 'display-value';
+import { describe, it, assert } from 'hippogriff';
+import TestClass from './data/TestClass.js';
+import { testTypes } from './data/testData.js';
+import multiTest from './multiTest.js';
+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]);
+        }
+    });
+}

package/dist/js/src/testMethod.js

@@ -0,0 +1,337 @@
+import displayValue from 'display-value';
+import { beforeEach, describe, it, assert } from 'hippogriff';
+import { powerset } from 'object-agent';
+const startCase = (string) => string.split(' ')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+const TEST_METHOD = 'testMethod';
+const everyMethodVariant = powerset(['get', 'other', 'before', 'set'])
+    .map((combination) => {
+    return {
+        name: TEST_METHOD + combination.map(startCase).join(''),
+        options: combination
+    };
+});
+const processOutput = (value, options = {}) => {
+    return (options.stringify && value && value.toString) ? value.toString() : value;
+};
+const beforeSymbol = Symbol();
+const setSymbol = Symbol();
+const getSymbol = Symbol();
+export default function (settings, thisMethod, method) {
+    let testBefore = '';
+    let testSet = '';
+    let self = this;
+    const testBeforeCallback = function (oldValue) {
+        self = this;
+        testBefore = processOutput(oldValue, settings.extraProps);
+    };
+    const testSetCallback = function (newValue) {
+        self = this;
+        testSet = processOutput(newValue, settings.extraProps);
+    };
+    const testGetCallback = function () {
+        self = this;
+        return settings.init;
+    };
+    const testGetCallbackWithTestItem = function () {
+        self = this;
+        return settings.true[0];
+    };
+    beforeEach(() => {
+        testBefore = null;
+        testSet = null;
+        self = null;
+    });
+    const runTests = (TestConstructor, init, testItem, coerce) => {
+        everyMethodVariant.forEach((methodData) => {
+            const methodName = methodData.name;
+            const hasGet = methodData.options.includes('get');
+            const hasOther = methodData.options.includes('other');
+            const hasBefore = methodData.options.includes('before');
+            const hasSet = methodData.options.includes('set');
+            describe('(' + methodName.replace('testMethod', '') + ')', () => {
+                it('should return the init value', () => {
+                    const testConstructor = new TestConstructor();
+                    assert.equal(testConstructor[methodName](), init);
+                });
+                it('should return "this" after a value is set', () => {
+                    const testConstructor = new TestConstructor();
+                    const that = testConstructor[methodName](testItem);
+                    assert.is(that, testConstructor);
+                });
+                if (hasGet) {
+                    it('should return whatever the "get" callback returns', () => {
+                        const testConstructor = new TestConstructor();
+                        testConstructor[methodName](testItem);
+                        assert.equal(testConstructor[methodName](), init);
+                        assert.is(testConstructor, self);
+                    });
+                }
+                else {
+                    it('should return a set value', () => {
+                        const testConstructor = new TestConstructor();
+                        testConstructor[methodName](testItem);
+                        assert.equal(testConstructor[methodName](), testItem);
+                    });
+                }
+                if (hasSet) {
+                    it('should execute the "set" callback when the value is set', () => {
+                        const testConstructor = new TestConstructor();
+                        testSet = '';
+                        testConstructor[methodName](testItem);
+                        assert.equal(testSet, testItem);
+                        assert.is(testConstructor, self);
+                    });
+                    it('should execute the "set" callback when the value is set to the current value and a second parameter of "true" is provided', () => {
+                        const testConstructor = new TestConstructor();
+                        testSet = '';
+                        testConstructor[methodName](testItem);
+                        testSet = '';
+                        testConstructor[methodName](testItem, true);
+                        assert.equal(testSet, testItem);
+                    });
+                    if (!hasGet) {
+                        it('should NOT execute the "set" callback when the value is set to the current value', () => {
+                            const testConstructor = new TestConstructor();
+                            testSet = '';
+                            testConstructor[methodName](testItem);
+                            testSet = '';
+                            testConstructor[methodName](testItem);
+                            assert.equal(testSet, '');
+                        });
+                    }
+                }
+                if (hasBefore) {
+                    it('should call the "before" callback with the init value when a value is set', () => {
+                        const testConstructor = new TestConstructor();
+                        testBefore = '';
+                        testConstructor[methodName](testItem);
+                        assert.equal(testBefore, init);
+                        assert.is(testConstructor, self);
+                    });
+                }
+                if (hasOther) {
+                    it('should be able to be set to other', () => {
+                        const testConstructor = new TestConstructor();
+                        if (!hasBefore && !hasGet) {
+                            testConstructor[methodName](undefined);
+                            assert.equal(testConstructor[methodName](), undefined);
+                        }
+                        else if (hasSet && init) {
+                            testSet = '';
+                            testConstructor[methodName](undefined);
+                            assert.equal(testSet, undefined);
+                        }
+                        else if (hasBefore && !hasGet && init) {
+                            testBefore = '';
+                            testConstructor[methodName](undefined);
+                            testConstructor[methodName](testItem);
+                            assert.equal(testBefore, undefined);
+                        }
+                        else if (hasBefore && hasGet && init) {
+                            testBefore = '';
+                            testConstructor[methodName](undefined);
+                            assert.equal(testBefore, init);
+                        }
+                    });
+                }
+                coerce.forEach((item) => {
+                    if (!hasGet) {
+                        it('should coerce ' + displayValue(item.value) + ' to ' + displayValue(item.coerced), () => {
+                            const testConstructor = new TestConstructor();
+                            testConstructor[methodName](item.value);
+                            assert.equal(testConstructor[methodName](), item.coerced);
+                        });
+                    }
+                    else if (hasSet) {
+                        it('should coerce ' + displayValue(item.value) + ' to ' + displayValue(item.coerced), () => {
+                            const testConstructor = new TestConstructor();
+                            testSet = '';
+                            testConstructor[methodName](item.value);
+                            assert.equal(testSet, item.coerced);
+                        });
+                    }
+                });
+            });
+        });
+        it('should not set the value of another method with the same variant', () => {
+            const testConstructor = new TestConstructor();
+            testConstructor[TEST_METHOD](testItem);
+            assert.equal(testConstructor[TEST_METHOD](), testItem);
+            assert.equal(testConstructor[TEST_METHOD + '2'](), init);
+        });
+    };
+    const getOptionCallback = (option, withTestItem, isReassigned, isSymbol) => {
+        if (isSymbol) {
+            switch (option) {
+                case 'get':
+                    return withTestItem ? testGetCallbackWithTestItem : getSymbol;
+                case 'other':
+                    return undefined;
+                case 'before':
+                    return beforeSymbol;
+                case 'set':
+                    return setSymbol;
+            }
+        }
+        if (isReassigned) {
+            switch (option) {
+                case 'get':
+                    return withTestItem ? testGetCallbackWithTestItem : 'testGetCallback';
+                case 'other':
+                    return undefined;
+                case 'before':
+                    return 'testBeforeCallback';
+                case 'set':
+                    return 'testSetCallback';
+            }
+        }
+        switch (option) {
+            case 'get':
+                return withTestItem ? testGetCallbackWithTestItem : testGetCallback;
+            case 'other':
+                return undefined;
+            case 'before':
+                return testBeforeCallback;
+            case 'set':
+                return testSetCallback;
+        }
+    };
+    const addMethodsTo = (applyTo, extraProperties = {}, isReassigned = false, isSymbol = false) => {
+        everyMethodVariant.forEach((methodData) => {
+            const options = {
+                ...settings.extraProps,
+                ...extraProperties
+            };
+            methodData.options.forEach((option) => {
+                options[option] = getOptionCallback(option, extraProperties.init, isReassigned, isSymbol);
+            });
+            applyTo[methodData.name] = method[settings.name](options);
+        });
+        applyTo[TEST_METHOD + '2'] = method[settings.name]({
+            ...settings.extraProps,
+            ...extraProperties
+        });
+    };
+    it('should exist in the exported "method" object', () => {
+        assert.equal(thisMethod, method[settings.name]);
+    });
+    describe('(prototype)', () => {
+        class TestConstructor1 {
+        }
+        addMethodsTo(TestConstructor1.prototype);
+        runTests(TestConstructor1, settings.init, settings.true[0], settings.coerce || []);
+    });
+    describe('(prototype) (reassigned methods string property)', () => {
+        class TestConstructor1 {
+            testBeforeCallback;
+            testSetCallback;
+            testGetCallback;
+            constructor() {
+                this.testBeforeCallback = testBeforeCallback;
+                this.testSetCallback = testSetCallback;
+                this.testGetCallback = testGetCallback;
+            }
+        }
+        addMethodsTo(TestConstructor1.prototype, {}, true);
+        runTests(TestConstructor1, settings.init, settings.true[0], settings.coerce || []);
+    });
+    describe('(prototype) (reassigned methods symbol property)', () => {
+        class TestConstructor1 {
+            [beforeSymbol];
+            [setSymbol];
+            [getSymbol];
+            constructor() {
+                this[beforeSymbol] = testBeforeCallback;
+                this[setSymbol] = testSetCallback;
+                this[getSymbol] = testGetCallback;
+            }
+        }
+        addMethodsTo(TestConstructor1.prototype, {}, true, true);
+        runTests(TestConstructor1, settings.init, settings.true[0], settings.coerce || []);
+    });
+    describe('(prototype) (reassigned method string proto)', () => {
+        class TestConstructor1 {
+        }
+        Object.assign(TestConstructor1.prototype, {
+            testBeforeCallback,
+            testSetCallback,
+            testGetCallback
+        });
+        addMethodsTo(TestConstructor1.prototype, {}, true);
+        runTests(TestConstructor1, settings.init, settings.true[0], settings.coerce || []);
+    });
+    describe('(prototype) (reassigned method symbol proto)', () => {
+        class TestConstructor1 {
+        }
+        Object.assign(TestConstructor1.prototype, {
+            [beforeSymbol]: testBeforeCallback,
+            [setSymbol]: testSetCallback,
+            [getSymbol]: testGetCallback
+        });
+        addMethodsTo(TestConstructor1.prototype, {}, true, true);
+        runTests(TestConstructor1, settings.init, settings.true[0], settings.coerce || []);
+    });
+    describe('(prototype) (init)', () => {
+        class TestConstructor2 {
+        }
+        addMethodsTo(TestConstructor2.prototype, {
+            init: settings.true[0]
+        });
+        runTests(TestConstructor2, settings.true[0], settings.true[1], settings.coerce || []);
+        settings.false.forEach((falseValue) => {
+            it(`should return ${displayValue(settings.true[0])} after attempting to set to ${displayValue(falseValue)}`, () => {
+                const testConstructor = new TestConstructor2();
+                testConstructor.testMethod(falseValue);
+                assert.equal(testConstructor.testMethod(), settings.true[0]);
+            });
+        });
+    });
+    describe('(property)', () => {
+        const TestConstructor3 = function () {
+            addMethodsTo(this);
+        };
+        runTests(TestConstructor3, settings.init, settings.true[0], settings.coerce || []);
+    });
+    describe('(property) (init)', () => {
+        const TestConstructor4 = function () {
+            addMethodsTo(this, {
+                init: settings.true[0]
+            });
+        };
+        runTests(TestConstructor4, settings.true[0], settings.true[1], settings.coerce || []);
+    });
+    if (settings.coerce !== false) {
+        describe('(prototype) (coerce=true)', () => {
+            class TestConstructor2 {
+            }
+            addMethodsTo(TestConstructor2.prototype, {
+                init: undefined,
+                coerce: true
+            });
+            settings.coerceTrue?.forEach((value) => {
+                it(`should return coerced ${displayValue(value)} after attempting to set to ${displayValue(value)}`, () => {
+                    const testConstructor = new TestConstructor2();
+                    testConstructor.testMethod(value);
+                    assert.notIs(testConstructor.testMethod(), undefined);
+                });
+            });
+        });
+        describe('(prototype) (coerce=false)', () => {
+            class TestConstructor2 {
+            }
+            addMethodsTo(TestConstructor2.prototype, {
+                init: undefined,
+                coerce: false
+            });
+            settings.coerceTrue?.forEach((value) => {
+                it(`should return coerced ${displayValue(value)} after attempting to set to ${displayValue(value)}`, () => {
+                    const testConstructor = new TestConstructor2();
+                    testConstructor.testMethod(value);
+                    assert.is(testConstructor.testMethod(), undefined);
+                });
+            });
+        });
+    }
+}

package/dist/js/src/utility/difference.js

@@ -0,0 +1,7 @@
+export default (array1, ...args) => {
+    const diffArrays = [];
+    args.forEach((arg) => {
+        diffArrays.push(...arg);
+    });
+    return array1.filter((item) => !diffArrays.includes(item));
+};

package/dist/types/index.d.ts

@@ -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/types/src/data/TestClass.d.ts

@@ -0,0 +1,6 @@
+export default class TestClass {
+    private _value;
+    constructor(value?: unknown);
+    get value(): unknown;
+    set value(value: unknown);
+}

package/dist/types/src/data/coercible.d.ts

@@ -0,0 +1,6 @@
+export declare const coerceArrayTrue: Array<unknown>;
+export declare const coerceInfinity: Array<unknown>;
+export declare const coerceIntegerTrue: Array<unknown>;
+export declare const coerceFloatTrue: Array<unknown>;
+export declare const coerceNumberFalse: Array<unknown>;
+export declare const coerceObjectTrue: Array<unknown>;

package/dist/types/src/data/testData.d.ts

@@ -0,0 +1,30 @@
+import { type is as Is } from 'type-enforcer';
+export interface TestData<T> {
+    value?: unknown;
+    skip?: Array<keyof typeof Is>;
+    name: keyof typeof Is;
+    true: Array<T>;
+    false: Array<unknown>;
+    coerceTrue: Array<unknown>;
+    coerceFalse: Array<unknown>;
+    extraArg?: T;
+}
+export declare const arrayData: TestData<Array<unknown>>;
+export declare const booleanData: TestData<boolean>;
+export declare const dateData: TestData<Date>;
+export declare const functionData: TestData<Function>;
+export declare const instanceData: TestData<unknown>;
+export declare const integerData: TestData<number>;
+export declare const jsonData: TestData<unknown>;
+export declare const floatData: TestData<number>;
+export declare const numberData: TestData<number>;
+export declare const mapData: TestData<Map<unknown, unknown>>;
+export declare const objectData: TestData<Object>;
+export declare const promiseData: TestData<Promise<unknown>>;
+export declare const regExpData: TestData<RegExp>;
+export declare const setData: TestData<Set<unknown>>;
+export declare const stringData: TestData<string>;
+export declare const symbolData: TestData<Symbol>;
+export declare const weakMapData: TestData<WeakMap<WeakRef<WeakKey>, unknown>>;
+export declare const weakSetData: TestData<WeakSet<WeakRef<WeakKey>>>;
+export declare const testTypes: Array<TestData<unknown>>;

package/dist/types/src/data/testData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/data/testValues.d.ts

@@ -0,0 +1,19 @@
+export declare const validArrays: Array<Array<unknown>>;
+export declare const validBooleans: Array<boolean>;
+export declare const validDates: Array<Date>;
+export declare const validFunctions: Array<Function>;
+export declare const validInstances: Array<unknown>;
+export declare const validIntegers: Array<number>;
+export declare const validFloats: Array<number>;
+export declare const validInfinities: Array<number>;
+export declare const validMaps: Array<Map<unknown, unknown>>;
+export declare const validObjects: Array<Object>;
+export declare const validPromises: Array<Promise<unknown>>;
+export declare const validRegExps: Array<RegExp>;
+export declare const validSets: Array<Set<unknown>>;
+export declare const validStrings: Array<string>;
+export declare const validSymbols: Array<Symbol>;
+export declare const validWeakMaps: Array<WeakMap<WeakRef<WeakKey>, unknown>>;
+export declare const validWeakSets: Array<WeakSet<WeakRef<WeakKey>>>;
+export declare const validNots: Array<undefined | null | typeof NaN>;
+export declare const testValues: Array<unknown>;

package/dist/types/src/data/testValues.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/multiTest.d.ts

@@ -0,0 +1,58 @@
+import { assert } from 'hippogriff';
+interface IMultiTestValuesObject<Type> {
+    [key: string]: Type;
+}
+interface IMultiTestSettingsObject<Type> {
+    values: IMultiTestValuesObject<Type>;
+    test: (value: Type) => unknown;
+    filter?: (value: unknown) => boolean;
+    message?: (input: unknown, output: unknown) => string;
+    output?: unknown;
+    assertion?: keyof typeof assert | 'true' | 'false';
+}
+interface IMultiTestSettingsPairs<Type> {
+    values: Array<Type>;
+    values2: Array<Type>;
+    test: (value1: Type, value2: Type) => unknown;
+    filter?: (value: Type, value2: Type) => boolean;
+    message?: (input: unknown, output: unknown) => string;
+    output?: unknown;
+    assertion?: keyof typeof assert | 'true' | 'false';
+    eachPair: true;
+}
+interface IMultiTestSettingsPairsCollection<Type, Values = {
+    [key: string]: Type;
+}> {
+    values: Array<Values>;
+    values2: Array<Values>;
+    test: (value1: Type, value2: Type) => unknown;
+    filter?: (value: Values, value2: Values) => boolean;
+    message?: (input: unknown, output: unknown) => string;
+    inputKey: keyof Values;
+    output?: unknown;
+    assertion?: keyof typeof assert | 'true' | 'false';
+    eachPair: true;
+}
+interface IMultiTestSettingsSingle<Type> {
+    values: Array<Type>;
+    test: (value: Type) => unknown;
+    filter?: (value: Type) => boolean;
+    message?: (input: unknown, output: unknown) => string;
+    output?: unknown;
+    assertion?: keyof typeof assert | 'true' | 'false';
+}
+interface IMultiTestSettingsSingleCollection<Type, Values = {
+    [key: string]: Type;
+}> {
+    values: Array<Values>;
+    test: (value: Type) => unknown;
+    filter?: (value: Values) => boolean;
+    message?: (input: unknown, output: unknown) => string;
+    inputKey?: keyof Values;
+    outputKey?: keyof Values;
+    output?: unknown;
+    assertion?: keyof typeof assert | 'true' | 'false';
+}
+type IMultiTestSettings<Type> = IMultiTestSettingsObject<Type> | IMultiTestSettingsPairs<Type> | IMultiTestSettingsPairsCollection<Type> | IMultiTestSettingsSingle<Type> | IMultiTestSettingsSingleCollection<Type>;
+declare const _default: <Type>(settings: IMultiTestSettings<Type>) => void;
+export default _default;

package/dist/types/src/multiTest.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/testCheck.d.ts

@@ -0,0 +1,3 @@
+import { type is as Is } from 'type-enforcer';
+import { TestData } from './data/testData.js';
+export default function (data: TestData<unknown>, check: (value: unknown, coerce?: boolean) => boolean, is: typeof Is): void;

package/dist/types/src/testCheck.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/testEnforce.d.ts

@@ -0,0 +1,2 @@
+import { type TestData } from './data/testData.js';
+export default function <Type>(data: TestData<Type>, enforcer: any, enforce: any, coercer: any): void;

package/dist/types/src/testEnforce.test.d.ts

@@ -0,0 +1 @@
+export {};