@ni/jasmine-parameterized 0.2.4 → 0.3.0

package/README.md

@@ -40,3 +40,37 @@ describe('Different rains', () => {
     });
 });
 ```
+
+### `parameterizeSuite`
+
+Use `parameterizeSuite` to create a parameterized test suite using an array of test scenarios with names.
+
+In the following example:
+
+ - the suite named `cats-and-dogs` is focused for debugging
+ - the suite named `frogs` is configured to always be disabled
+ - the suite named `men` will run normally as it has no override
+
+```ts
+import { parameterizeSuite } from '@ni/jasmine-parameterized';
+const rainTests = [
+    { name: 'cats-and-dogs', type: 'idiom' },
+    { name: 'frogs' type: 'idiom'},
+    { name: 'men', type: 'lyrics'}
+] as const;
+parameterizeSuite(rainTests, (suite, name, value) => {
+    suite(`with ${name}`, () => {
+        it('expect type to be defined', () => {
+            expect(value.type).toBeDefined();
+        });
+
+        it('expect type to have a non-zero length', () => {
+            const length = value.type.length;
+            expect(length).toBeGreaterThan(0);
+        });
+    });
+}, {
+    'cats-and-dogs': fdescribe,
+    frogs: xdescribe
+});
+```

package/dist/esm/index.d.ts

@@ -1 +1,2 @@
-export { parameterizeSpec } from './parameterized.js';
+export { parameterizeSpec } from './parameterize-spec.js';
+export { parameterizeSuite } from './parameterize-suite.js';

package/dist/esm/index.js

@@ -1,2 +1,3 @@
-export { parameterizeSpec } from './parameterized.js';
+export { parameterizeSpec } from './parameterize-spec.js';
+export { parameterizeSuite } from './parameterize-suite.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC","sourcesContent":["export { parameterizeSpec } from './parameterized.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["export { parameterizeSpec } from './parameterize-spec.js';\nexport { parameterizeSuite } from './parameterize-suite.js';\n"]}

package/dist/esm/parameterize-spec.d.ts

@@ -0,0 +1,29 @@
+import { ObjectFromNamedList, Spec, SpecOverride } from './types.js';
+/**
+ * Used to create a parameterized test using an array of tests with names.
+ * In the following example:
+ *  - the test named `cats-and-dogs` is focused for debugging
+ *  - the test named `frogs` is configured to always be disabled
+ *  - the test named `men` will run normally as it has no override
+ * @example
+ * const rainTests = [
+ *   { name: 'cats-and-dogs', type: 'idiom' },
+ *   { name: 'frogs' type: 'idiom'},
+ *   { name: 'men', type: 'lyrics'}
+ * ] as const;
+ * describe('Different rains', () => {
+ *     parameterizeSpec(rainTests, (spec, name, value) => {
+ *         spec(`of type ${name} exist`, () => {
+ *             expect(value.type).toBeDefined();
+ *         });
+ *     }, {
+ *         'cats-and-dogs': fit,
+ *         frogs: xit
+ *     });
+ * });
+ */
+export declare const parameterizeSpec: <T extends readonly {
+    name: string;
+}[]>(list: T, test: (spec: Spec, name: T extends readonly {
+    name: infer U;
+}[] ? U : never, value: T[number]) => void, specOverrides?: { [P in keyof ObjectFromNamedList<T>]?: SpecOverride | undefined; } | undefined) => void;

package/dist/esm/parameterize-spec.js

@@ -0,0 +1,35 @@
+import { parameterize } from './parameterize.js';
+/**
+ * Used to create a parameterized test using an array of tests with names.
+ * In the following example:
+ *  - the test named `cats-and-dogs` is focused for debugging
+ *  - the test named `frogs` is configured to always be disabled
+ *  - the test named `men` will run normally as it has no override
+ * @example
+ * const rainTests = [
+ *   { name: 'cats-and-dogs', type: 'idiom' },
+ *   { name: 'frogs' type: 'idiom'},
+ *   { name: 'men', type: 'lyrics'}
+ * ] as const;
+ * describe('Different rains', () => {
+ *     parameterizeSpec(rainTests, (spec, name, value) => {
+ *         spec(`of type ${name} exist`, () => {
+ *             expect(value.type).toBeDefined();
+ *         });
+ *     }, {
+ *         'cats-and-dogs': fit,
+ *         frogs: xit
+ *     });
+ * });
+ */
+export const parameterizeSpec = (list, test, specOverrides) => {
+    const testCases = list.reduce((result, entry) => {
+        if (result[entry.name]) {
+            throw new Error(`Duplicate name found in test case list: ${entry.name}. Make sure all test names are unique.`);
+        }
+        result[entry.name] = entry;
+        return result;
+    }, {});
+    parameterize('spec', testCases, test, specOverrides);
+};
+//# sourceMappingURL=parameterize-spec.js.map

package/dist/esm/parameterize-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameterize-spec.js","sourceRoot":"","sources":["../../src/parameterize-spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC5B,IAAO,EACP,IAIS,EACT,aAEC,EACG,EAAE;IACN,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CACzB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QACd,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YACpB,MAAM,IAAI,KAAK,CACX,2CAA2C,KAAK,CAAC,IAAI,wCAAwC,CAChG,CAAC;SACL;QACD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC,EACD,EAAE,CACqB,CAAC;IAC5B,YAAY,CAAyB,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;AACjF,CAAC,CAAC","sourcesContent":["import { parameterize } from './parameterize.js';\nimport { ObjectFromNamedList, Spec, SpecOverride } from './types.js';\n\n/**\n * Used to create a parameterized test using an array of tests with names.\n * In the following example:\n *  - the test named `cats-and-dogs` is focused for debugging\n *  - the test named `frogs` is configured to always be disabled\n *  - the test named `men` will run normally as it has no override\n * @example\n * const rainTests = [\n *   { name: 'cats-and-dogs', type: 'idiom' },\n *   { name: 'frogs' type: 'idiom'},\n *   { name: 'men', type: 'lyrics'}\n * ] as const;\n * describe('Different rains', () => {\n *     parameterizeSpec(rainTests, (spec, name, value) => {\n *         spec(`of type ${name} exist`, () => {\n *             expect(value.type).toBeDefined();\n *         });\n *     }, {\n *         'cats-and-dogs': fit,\n *         frogs: xit\n *     });\n * });\n */\nexport const parameterizeSpec = <T extends readonly { name: string }[]>(\n    list: T,\n    test: (\n        spec: Spec,\n        name: keyof ObjectFromNamedList<T>,\n        value: T[number]\n    ) => void,\n    specOverrides?: {\n        [P in keyof ObjectFromNamedList<T>]?: SpecOverride;\n    }\n): void => {\n    const testCases = list.reduce<{ [key: string]: { name: string } }>(\n        (result, entry) => {\n            if (result[entry.name]) {\n                throw new Error(\n                    `Duplicate name found in test case list: ${entry.name}. Make sure all test names are unique.`\n                );\n            }\n            result[entry.name] = entry;\n            return result;\n        },\n        {}\n    ) as ObjectFromNamedList<T>;\n    parameterize<ObjectFromNamedList<T>>('spec', testCases, test, specOverrides);\n};\n"]}

package/dist/esm/parameterize-suite.d.ts

@@ -0,0 +1,34 @@
+import { ObjectFromNamedList, Suite, SuiteOverride } from './types.js';
+/**
+ * Used to create a parameterized suite using an array of test scenarios with names.
+ * In the following example:
+ *  - the suite named `cats-and-dogs` is focused for debugging
+ *  - the suite named `frogs` is configured to always be disabled
+ *  - the suite named `men` will run normally as it has no override
+ * @example
+* const rainTests = [
+*   { name: 'cats-and-dogs', type: 'idiom' },
+*   { name: 'frogs' type: 'idiom'},
+*   { name: 'men', type: 'lyrics'}
+* ] as const;
+* parameterizeSuite(rainTests, (suite, name, value) => {
+*     suite(`with ${name}`, () => {
+*         it('expect type to be defined', () => {
+*             expect(value.type).toBeDefined();
+*         });
+*
+*         it('expect type to have a non-zero length', () => {
+*             const length = value.type.length;
+*             expect(length).toBeGreaterThan(0);
+*         });
+*     });
+* }, {
+*     'cats-and-dogs': fdescribe,
+*     frogs: xdescribe
+* });
+*/
+export declare const parameterizeSuite: <T extends readonly {
+    name: string;
+}[]>(list: T, test: (suite: Suite, name: T extends readonly {
+    name: infer U;
+}[] ? U : never, value: T[number]) => void, specOverrides?: { [P in keyof ObjectFromNamedList<T>]?: SuiteOverride | undefined; } | undefined) => void;

package/dist/esm/parameterize-suite.js

@@ -0,0 +1,40 @@
+import { parameterize } from './parameterize.js';
+/**
+ * Used to create a parameterized suite using an array of test scenarios with names.
+ * In the following example:
+ *  - the suite named `cats-and-dogs` is focused for debugging
+ *  - the suite named `frogs` is configured to always be disabled
+ *  - the suite named `men` will run normally as it has no override
+ * @example
+* const rainTests = [
+*   { name: 'cats-and-dogs', type: 'idiom' },
+*   { name: 'frogs' type: 'idiom'},
+*   { name: 'men', type: 'lyrics'}
+* ] as const;
+* parameterizeSuite(rainTests, (suite, name, value) => {
+*     suite(`with ${name}`, () => {
+*         it('expect type to be defined', () => {
+*             expect(value.type).toBeDefined();
+*         });
+*
+*         it('expect type to have a non-zero length', () => {
+*             const length = value.type.length;
+*             expect(length).toBeGreaterThan(0);
+*         });
+*     });
+* }, {
+*     'cats-and-dogs': fdescribe,
+*     frogs: xdescribe
+* });
+*/
+export const parameterizeSuite = (list, test, specOverrides) => {
+    const testCases = list.reduce((result, entry) => {
+        if (result[entry.name]) {
+            throw new Error(`Duplicate name found in test suite list: ${entry.name}. Make sure all test suite names are unique.`);
+        }
+        result[entry.name] = entry;
+        return result;
+    }, {});
+    parameterize('suite', testCases, test, specOverrides);
+};
+//# sourceMappingURL=parameterize-suite.js.map

package/dist/esm/parameterize-suite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameterize-suite.js","sourceRoot":"","sources":["../../src/parameterize-suite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BE;AACF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC7B,IAAO,EACP,IAIS,EACT,aAEC,EACG,EAAE;IACN,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CACzB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QACd,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YACpB,MAAM,IAAI,KAAK,CACX,4CAA4C,KAAK,CAAC,IAAI,8CAA8C,CACvG,CAAC;SACL;QACD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC,EACD,EAAE,CACqB,CAAC;IAC5B,YAAY,CAAyB,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;AAClF,CAAC,CAAC","sourcesContent":["import { parameterize } from './parameterize.js';\nimport { ObjectFromNamedList, Suite, SuiteOverride } from './types.js';\n\n/**\n * Used to create a parameterized suite using an array of test scenarios with names.\n * In the following example:\n *  - the suite named `cats-and-dogs` is focused for debugging\n *  - the suite named `frogs` is configured to always be disabled\n *  - the suite named `men` will run normally as it has no override\n * @example\n* const rainTests = [\n*   { name: 'cats-and-dogs', type: 'idiom' },\n*   { name: 'frogs' type: 'idiom'},\n*   { name: 'men', type: 'lyrics'}\n* ] as const;\n* parameterizeSuite(rainTests, (suite, name, value) => {\n*     suite(`with ${name}`, () => {\n*         it('expect type to be defined', () => {\n*             expect(value.type).toBeDefined();\n*         });\n*\n*         it('expect type to have a non-zero length', () => {\n*             const length = value.type.length;\n*             expect(length).toBeGreaterThan(0);\n*         });\n*     });\n* }, {\n*     'cats-and-dogs': fdescribe,\n*     frogs: xdescribe\n* });\n*/\nexport const parameterizeSuite = <T extends readonly { name: string }[]>(\n    list: T,\n    test: (\n        suite: Suite,\n        name: keyof ObjectFromNamedList<T>,\n        value: T[number]\n    ) => void,\n    specOverrides?: {\n        [P in keyof ObjectFromNamedList<T>]?: SuiteOverride;\n    }\n): void => {\n    const testCases = list.reduce<{ [key: string]: { name: string } }>(\n        (result, entry) => {\n            if (result[entry.name]) {\n                throw new Error(\n                    `Duplicate name found in test suite list: ${entry.name}. Make sure all test suite names are unique.`\n                );\n            }\n            result[entry.name] = entry;\n            return result;\n        },\n        {}\n    ) as ObjectFromNamedList<T>;\n    parameterize<ObjectFromNamedList<T>>('suite', testCases, test, specOverrides);\n};\n"]}

package/dist/esm/parameterize.d.ts

@@ -0,0 +1,30 @@
+import { Spec, SpecOverride, Suite, SuiteOverride } from './types.js';
+/**
+ * Used to create a parameterized test or suite using an object of names and arbitrary test values.
+ * In the following example:
+ *  - the test named `catsAndDogs` is focused for debugging
+ *  - the test named `frogs` is configured to always be disabled
+ *  - the test named `men` will run normally as it has no override
+ * @example
+ * const rainTests = {
+ *     catsAndDogs: 'idiom',
+ *     frogs: 'idiom',
+ *     men: 'lyrics'
+ * } as const;
+ * describe('Different rains', () => {
+ *     parameterize('spec', rainTests, (spec, name, value) => {
+ *         spec(`of type ${name} exist`, () => {
+ *             expect(value).toBeDefined();
+ *         });
+ *     }, {
+ *         catsAndDogs: fit,
+ *         frogs: xit
+ *     });
+ * });
+ */
+export declare function parameterize<T extends object>(testType: 'spec', testCases: T, test: (spec: Spec, name: keyof T, value: T[keyof T]) => void, overrides?: {
+    [P in keyof T]?: SpecOverride;
+}): void;
+export declare function parameterize<T extends object>(testType: 'suite', testCases: T, test: (spec: Suite, name: keyof T, value: T[keyof T]) => void, overrides?: {
+    [P in keyof T]?: SuiteOverride;
+}): void;

package/dist/esm/parameterize.js

@@ -0,0 +1,25 @@
+export function parameterize(testType, testCases, test, overrides) {
+    const testCaseNames = Object.keys(testCases);
+    if (overrides) {
+        const overrideNames = Object.keys(overrides);
+        if (!overrideNames.every(overrideName => testCaseNames.includes(overrideName))) {
+            throw new Error('Parameterized test override names must match test case name');
+        }
+        if (testType === 'spec'
+            // eslint-disable-next-line no-restricted-globals
+            && !overrideNames.every(overrideName => [fit, xit].includes(overrides[overrideName]))) {
+            throw new Error('Must configure override with one of the jasmine spec functions: fit or xit');
+        }
+        if (testType === 'suite'
+            // eslint-disable-next-line no-restricted-globals
+            && !overrideNames.every(overrideName => [fdescribe, xdescribe].includes(overrides[overrideName]))) {
+            throw new Error('Must configure override with one of the jasmine suite functions: fdescribe or xdescribe');
+        }
+    }
+    testCaseNames.forEach(testCaseName => {
+        const defaultTest = testType === 'spec' ? it : describe;
+        const spec = overrides?.[testCaseName] ?? defaultTest;
+        test(spec, testCaseName, testCases[testCaseName]);
+    });
+}
+//# sourceMappingURL=parameterize.js.map

package/dist/esm/parameterize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameterize.js","sourceRoot":"","sources":["../../src/parameterize.ts"],"names":[],"mappings":"AAyCA,MAAM,UAAU,YAAY,CACxB,QAA0B,EAC1B,SAAY,EACZ,IAAyD,EACzD,SAEC;IAED,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAgB,CAAC;IAC5D,IAAI,SAAS,EAAE;QACX,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAC7B,SAAS,CACkB,CAAC;QAChC,IACI,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,EAC5E;YACE,MAAM,IAAI,KAAK,CACX,6DAA6D,CAChE,CAAC;SACL;QACD,IACI,QAAQ,KAAK,MAAM;YACnB,iDAAiD;eAC9C,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAS,CAAC,CAAC,EAC/F;YACE,MAAM,IAAI,KAAK,CAAC,4EAA4E,CAAC,CAAC;SACjG;QACD,IACI,QAAQ,KAAK,OAAO;YACpB,iDAAiD;eAC9C,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAU,CAAC,CAAC,EAC5G;YACE,MAAM,IAAI,KAAK,CACX,yFAAyF,CAC5F,CAAC;SACL;KACJ;IACD,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;QACjC,MAAM,WAAW,GAAG,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;QACxD,MAAM,IAAI,GAAG,SAAS,EAAE,CAAC,YAAY,CAAC,IAAI,WAAW,CAAC;QACtD,IAAI,CAAC,IAAS,EAAE,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;AACP,CAAC","sourcesContent":["import { Spec, SpecOverride, Suite, SuiteOverride } from './types.js';\n\n/**\n * Used to create a parameterized test or suite using an object of names and arbitrary test values.\n * In the following example:\n *  - the test named `catsAndDogs` is focused for debugging\n *  - the test named `frogs` is configured to always be disabled\n *  - the test named `men` will run normally as it has no override\n * @example\n * const rainTests = {\n *     catsAndDogs: 'idiom',\n *     frogs: 'idiom',\n *     men: 'lyrics'\n * } as const;\n * describe('Different rains', () => {\n *     parameterize('spec', rainTests, (spec, name, value) => {\n *         spec(`of type ${name} exist`, () => {\n *             expect(value).toBeDefined();\n *         });\n *     }, {\n *         catsAndDogs: fit,\n *         frogs: xit\n *     });\n * });\n */\nexport function parameterize<T extends object>(\n    testType: 'spec',\n    testCases: T,\n    test: (spec: Spec, name: keyof T, value: T[keyof T]) => void,\n    overrides?: {\n        [P in keyof T]?: SpecOverride;\n    }\n): void;\nexport function parameterize<T extends object>(\n    testType: 'suite',\n    testCases: T,\n    test: (spec: Suite, name: keyof T, value: T[keyof T]) => void,\n    overrides?: {\n        [P in keyof T]?: SuiteOverride;\n    }\n): void;\nexport function parameterize<T extends object, U = Spec | Suite>(\n    testType: 'spec' | 'suite',\n    testCases: T,\n    test: (spec: U, name: keyof T, value: T[keyof T]) => void,\n    overrides?: {\n        [P in keyof T]?: U extends Spec ? SpecOverride : SuiteOverride;\n    }\n): void {\n    const testCaseNames = Object.keys(testCases) as (keyof T)[];\n    if (overrides) {\n        const overrideNames = Object.keys(\n            overrides\n        ) as (keyof typeof overrides)[];\n        if (\n            !overrideNames.every(overrideName => testCaseNames.includes(overrideName))\n        ) {\n            throw new Error(\n                'Parameterized test override names must match test case name'\n            );\n        }\n        if (\n            testType === 'spec'\n            // eslint-disable-next-line no-restricted-globals\n            && !overrideNames.every(overrideName => [fit, xit].includes(overrides[overrideName] as Spec))\n        ) {\n            throw new Error('Must configure override with one of the jasmine spec functions: fit or xit');\n        }\n        if (\n            testType === 'suite'\n            // eslint-disable-next-line no-restricted-globals\n            && !overrideNames.every(overrideName => [fdescribe, xdescribe].includes(overrides[overrideName] as Suite))\n        ) {\n            throw new Error(\n                'Must configure override with one of the jasmine suite functions: fdescribe or xdescribe'\n            );\n        }\n    }\n    testCaseNames.forEach(testCaseName => {\n        const defaultTest = testType === 'spec' ? it : describe;\n        const spec = overrides?.[testCaseName] ?? defaultTest;\n        test(spec as U, testCaseName, testCases[testCaseName]);\n    });\n}"]}

package/dist/esm/types.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="jasmine" />
+export type Fit = typeof fit;
+export type Xit = typeof xit;
+export type It = typeof it;
+/**
+ * One of the jasmine spec functions: fit, xit, or it
+ */
+export type Spec = Fit | Xit | It;
+/**
+ * One of the jasmine spec functions: fit or xit
+ */
+export type SpecOverride = Fit | Xit;
+export type Fdescribe = typeof fdescribe;
+export type Xdescribe = typeof xdescribe;
+export type Describe = typeof describe;
+/**
+ * One of the jasmine spec functions: fit, xit, or it
+ */
+export type Suite = Fdescribe | Xdescribe | Describe;
+/**
+ * One of the jasmine spec functions: fit or xit
+ */
+export type SuiteOverride = Fdescribe | Xdescribe;
+export type ObjectFromNamedList<T extends readonly {
+    name: string;
+}[]> = {
+    [K in T extends readonly {
+        name: infer U;
+    }[] ? U : never]: T[number];
+};

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"","sourcesContent":["// The following aliases are just to reduce the number\n// of eslint disables in this source file. In normal\n// test code use the globals directly so eslint can\n// guard accidental check-ins of fit, etc.\n// eslint-disable-next-line no-restricted-globals\nexport type Fit = typeof fit;\nexport type Xit = typeof xit;\nexport type It = typeof it;\n/**\n * One of the jasmine spec functions: fit, xit, or it\n */\nexport type Spec = Fit | Xit | It;\n/**\n * One of the jasmine spec functions: fit or xit\n */\nexport type SpecOverride = Fit | Xit;\n\n// eslint-disable-next-line no-restricted-globals\nexport type Fdescribe = typeof fdescribe;\nexport type Xdescribe = typeof xdescribe;\nexport type Describe = typeof describe;\n/**\n * One of the jasmine spec functions: fit, xit, or it\n */\nexport type Suite = Fdescribe | Xdescribe | Describe;\n/**\n * One of the jasmine spec functions: fit or xit\n */\nexport type SuiteOverride = Fdescribe | Xdescribe;\n\nexport type ObjectFromNamedList<T extends readonly { name: string }[]> = {\n    [K in T extends readonly { name: infer U }[] ? U : never]: T[number];\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ni/jasmine-parameterized",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "A utility to write parameterized jasmine tests",
   "keywords": [
     "jasmine",

package/dist/esm/parameterized.d.ts

@@ -1,72 +0,0 @@
-/// <reference types="jasmine" />
-type Fit = typeof fit;
-type Xit = typeof xit;
-type It = typeof it;
-/**
- * One of the jasmine spec functions: fit, xit, or it
- */
-type Spec = Fit | Xit | It;
-/**
- * One of the jasmine spec functions: fit or xit
- */
-type SpecOverride = Fit | Xit;
-/**
- * Used to create a parameterized test using an object of test names and arbitrary test values.
- * In the following example:
- *  - the test named `catsAndDogs` is focused for debugging
- *  - the test named `frogs` is configured to always be disabled
- *  - the test named `men` will run normally as it has no override
- * @example
- * const rainTests = {
- *     catsAndDogs: 'idiom',
- *     frogs: 'idiom',
- *     men: 'lyrics'
- * } as const;
- * describe('Different rains', () => {
- *     parameterize(rainTests, (spec, name, value) => {
- *         spec(`of type ${name} exist`, () => {
- *             expect(value).toBeDefined();
- *         });
- *     }, {
- *         catsAndDogs: fit,
- *         frogs: xit
- *     });
- * });
- */
-export declare const parameterize: <T extends object>(testCases: T, test: (spec: Spec, name: keyof T, value: T[keyof T]) => void, specOverrides?: { [P in keyof T]?: SpecOverride | undefined; } | undefined) => void;
-type ObjectFromNamedList<T extends readonly {
-    name: string;
-}[]> = {
-    [K in T extends readonly {
-        name: infer U;
-    }[] ? U : never]: T[number];
-};
-/**
- * Used to create a parameterized test using an array of tests with names.
- * In the following example:
- *  - the test named `cats-and-dogs` is focused for debugging
- *  - the test named `frogs` is configured to always be disabled
- *  - the test named `men` will run normally as it has no override
- * @example
- * const rainTests = [
- *   { name: 'cats-and-dogs', type: 'idiom' },
- *   { name: 'frogs', type: 'idiom'},
- *   { name: 'men', type: 'lyrics'}
- * ] as const;
- * describe('Different rains', () => {
- *     parameterizeSpec(rainTests, (spec, name, value) => {
- *         spec(`of type ${name} exist`, () => {
- *             expect(value.type).toBeDefined();
- *         });
- *     }, {
- *         'cats-and-dogs': fit,
- *         frogs: xit
- *     });
- * });
- */
-export declare const parameterizeSpec: <T extends readonly {
-    name: string;
-}[]>(list: T, test: (spec: Spec, name: T extends readonly {
-    name: infer U;
-}[] ? U : never, value: T[number]) => void, specOverrides?: { [P in keyof ObjectFromNamedList<T>]?: SpecOverride | undefined; } | undefined) => void;
-export {};

package/dist/esm/parameterized.js

@@ -1,75 +0,0 @@
-/**
- * Used to create a parameterized test using an object of test names and arbitrary test values.
- * In the following example:
- *  - the test named `catsAndDogs` is focused for debugging
- *  - the test named `frogs` is configured to always be disabled
- *  - the test named `men` will run normally as it has no override
- * @example
- * const rainTests = {
- *     catsAndDogs: 'idiom',
- *     frogs: 'idiom',
- *     men: 'lyrics'
- * } as const;
- * describe('Different rains', () => {
- *     parameterize(rainTests, (spec, name, value) => {
- *         spec(`of type ${name} exist`, () => {
- *             expect(value).toBeDefined();
- *         });
- *     }, {
- *         catsAndDogs: fit,
- *         frogs: xit
- *     });
- * });
- */
-export const parameterize = (testCases, test, specOverrides) => {
-    const testCaseNames = Object.keys(testCases);
-    if (specOverrides) {
-        const overrideNames = Object.keys(specOverrides);
-        if (!overrideNames.every(overrideName => testCaseNames.includes(overrideName))) {
-            throw new Error('Parameterized test override names must match test case name');
-        }
-        if (
-        // eslint-disable-next-line no-restricted-globals
-        !overrideNames.every(overrideName => [fit, xit].includes(specOverrides[overrideName]))) {
-            throw new Error('Must configure override with one of the jasmine spec functions: fit or xit');
-        }
-    }
-    testCaseNames.forEach(testCaseName => {
-        const spec = specOverrides?.[testCaseName] ?? it;
-        test(spec, testCaseName, testCases[testCaseName]);
-    });
-};
-/**
- * Used to create a parameterized test using an array of tests with names.
- * In the following example:
- *  - the test named `cats-and-dogs` is focused for debugging
- *  - the test named `frogs` is configured to always be disabled
- *  - the test named `men` will run normally as it has no override
- * @example
- * const rainTests = [
- *   { name: 'cats-and-dogs', type: 'idiom' },
- *   { name: 'frogs', type: 'idiom'},
- *   { name: 'men', type: 'lyrics'}
- * ] as const;
- * describe('Different rains', () => {
- *     parameterizeSpec(rainTests, (spec, name, value) => {
- *         spec(`of type ${name} exist`, () => {
- *             expect(value.type).toBeDefined();
- *         });
- *     }, {
- *         'cats-and-dogs': fit,
- *         frogs: xit
- *     });
- * });
- */
-export const parameterizeSpec = (list, test, specOverrides) => {
-    const testCases = list.reduce((result, entry) => {
-        if (result[entry.name]) {
-            throw new Error(`Duplicate name found in test case list: ${entry.name}. Make sure all test names are unique.`);
-        }
-        result[entry.name] = entry;
-        return result;
-    }, {});
-    parameterize(testCases, test, specOverrides);
-};
-//# sourceMappingURL=parameterized.js.map

package/dist/esm/parameterized.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parameterized.js","sourceRoot":"","sources":["../../src/parameterized.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CACxB,SAAY,EACZ,IAA4D,EAC5D,aAEC,EACG,EAAE;IACN,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAgB,CAAC;IAC5D,IAAI,aAAa,EAAE;QACf,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAC7B,aAAa,CACkB,CAAC;QACpC,IACI,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,EAC5E;YACE,MAAM,IAAI,KAAK,CACX,6DAA6D,CAChE,CAAC;SACL;QACD;QACI,iDAAiD;QACjD,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,YAAY,CAAE,CAAC,CAAC,EACzF;YACE,MAAM,IAAI,KAAK,CACX,4EAA4E,CAC/E,CAAC;SACL;KACJ;IACD,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;QACjC,MAAM,IAAI,GAAG,aAAa,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QACjD,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC5B,IAAO,EACP,IAIS,EACT,aAEC,EACG,EAAE;IACN,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CACzB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QACd,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YACpB,MAAM,IAAI,KAAK,CACX,2CAA2C,KAAK,CAAC,IAAI,wCAAwC,CAChG,CAAC;SACL;QACD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAC3B,OAAO,MAAM,CAAC;IAClB,CAAC,EACD,EAAE,CACqB,CAAC;IAC5B,YAAY,CAAyB,SAAS,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;AACzE,CAAC,CAAC","sourcesContent":["// The following aliases are just to reduce the number\n// of eslint disables in this source file. In normal\n// test code use the globals directly so eslint can\n// guard accidental check-ins of fit, etc.\n// eslint-disable-next-line no-restricted-globals\ntype Fit = typeof fit;\ntype Xit = typeof xit;\ntype It = typeof it;\n/**\n * One of the jasmine spec functions: fit, xit, or it\n */\ntype Spec = Fit | Xit | It;\n/**\n * One of the jasmine spec functions: fit or xit\n */\ntype SpecOverride = Fit | Xit;\n\n/**\n * Used to create a parameterized test using an object of test names and arbitrary test values.\n * In the following example:\n *  - the test named `catsAndDogs` is focused for debugging\n *  - the test named `frogs` is configured to always be disabled\n *  - the test named `men` will run normally as it has no override\n * @example\n * const rainTests = {\n *     catsAndDogs: 'idiom',\n *     frogs: 'idiom',\n *     men: 'lyrics'\n * } as const;\n * describe('Different rains', () => {\n *     parameterize(rainTests, (spec, name, value) => {\n *         spec(`of type ${name} exist`, () => {\n *             expect(value).toBeDefined();\n *         });\n *     }, {\n *         catsAndDogs: fit,\n *         frogs: xit\n *     });\n * });\n */\nexport const parameterize = <T extends object>(\n    testCases: T,\n    test: (spec: Spec, name: keyof T, value: T[keyof T]) => void,\n    specOverrides?: {\n        [P in keyof T]?: SpecOverride;\n    }\n): void => {\n    const testCaseNames = Object.keys(testCases) as (keyof T)[];\n    if (specOverrides) {\n        const overrideNames = Object.keys(\n            specOverrides\n        ) as (keyof typeof specOverrides)[];\n        if (\n            !overrideNames.every(overrideName => testCaseNames.includes(overrideName))\n        ) {\n            throw new Error(\n                'Parameterized test override names must match test case name'\n            );\n        }\n        if (\n            // eslint-disable-next-line no-restricted-globals\n            !overrideNames.every(overrideName => [fit, xit].includes(specOverrides[overrideName]!))\n        ) {\n            throw new Error(\n                'Must configure override with one of the jasmine spec functions: fit or xit'\n            );\n        }\n    }\n    testCaseNames.forEach(testCaseName => {\n        const spec = specOverrides?.[testCaseName] ?? it;\n        test(spec, testCaseName, testCases[testCaseName]);\n    });\n};\n\ntype ObjectFromNamedList<T extends readonly { name: string }[]> = {\n    [K in T extends readonly { name: infer U }[] ? U : never]: T[number];\n};\n\n/**\n * Used to create a parameterized test using an array of tests with names.\n * In the following example:\n *  - the test named `cats-and-dogs` is focused for debugging\n *  - the test named `frogs` is configured to always be disabled\n *  - the test named `men` will run normally as it has no override\n * @example\n * const rainTests = [\n *   { name: 'cats-and-dogs', type: 'idiom' },\n *   { name: 'frogs', type: 'idiom'},\n *   { name: 'men', type: 'lyrics'}\n * ] as const;\n * describe('Different rains', () => {\n *     parameterizeSpec(rainTests, (spec, name, value) => {\n *         spec(`of type ${name} exist`, () => {\n *             expect(value.type).toBeDefined();\n *         });\n *     }, {\n *         'cats-and-dogs': fit,\n *         frogs: xit\n *     });\n * });\n */\nexport const parameterizeSpec = <T extends readonly { name: string }[]>(\n    list: T,\n    test: (\n        spec: Spec,\n        name: keyof ObjectFromNamedList<T>,\n        value: T[number]\n    ) => void,\n    specOverrides?: {\n        [P in keyof ObjectFromNamedList<T>]?: SpecOverride;\n    }\n): void => {\n    const testCases = list.reduce<{ [key: string]: { name: string } }>(\n        (result, entry) => {\n            if (result[entry.name]) {\n                throw new Error(\n                    `Duplicate name found in test case list: ${entry.name}. Make sure all test names are unique.`\n                );\n            }\n            result[entry.name] = entry;\n            return result;\n        },\n        {}\n    ) as ObjectFromNamedList<T>;\n    parameterize<ObjectFromNamedList<T>>(testCases, test, specOverrides);\n};\n"]}