@flemist/test-variants 0.0.0

package/README.md

@@ -0,0 +1,70 @@
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Build Status][github-image]][github-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Runs a test function with all possible combinations of its parameters.
+
+# Usage
+
+## Sync only
+```ts
+const result = []
+const testVariants = createTestVariantsSync(({a, b, c}: { a: number, b: string, c: boolean }) => {
+    result.push([a, b, c])
+})
+const count = testVariants({
+    a: [1, 2],
+    b: ['3', '4'],
+    c: [true, false],
+})
+
+// result == [
+//     [1, '3', true],
+//     [1, '3', false],
+//     [1, '4', true],
+//     [1, '4', false],
+//     [2, '3', true],
+//     [2, '3', false],
+//     [2, '4', true],
+//     [2, '4', false],
+// ]
+// count == 8
+```
+
+## Sync or Async
+```ts
+const result = []
+const testVariants = createTestVariants(async ({a, b, c}: { a: number, b: string, c: boolean }) => {
+  await delay(10)
+  result.push([a, b, c])
+})
+const count = await testVariants({
+    a: [1, 2],
+    b: ['3', '4'],
+    c: [true, false],
+})
+```
+
+## Calculable variants
+```ts
+const result = []
+const testVariants = createTestVariants(async ({a, b, c}: { a: number, b: number, c: number }) => {
+  await delay(10)
+  result.push([a, b, c])
+})
+const count = await testVariants({
+    a: [1, 2],
+    b: ({a}) => [ a + 1, a + 2 ], // you can use 'a', but you can't use 'c' because it will initialize after 'b' 
+    c: ({a, b}) => [ a, b, a + b ],
+})
+```
+
+[npm-image]: https://img.shields.io/npm/v/@flemist/test-variants.svg
+[npm-url]: https://npmjs.org/package/@flemist/test-variants
+[downloads-image]: https://img.shields.io/npm/dm/@flemist/test-variants.svg
+[downloads-url]: https://npmjs.org/package/@flemist/test-variants
+[github-image]: https://github.com/NikolayMakhonin/test-variants/actions/workflows/test.yml/badge.svg
+[github-url]: https://github.com/NikolayMakhonin/test-variants/actions
+[coveralls-image]: https://coveralls.io/repos/github/NikolayMakhonin/test-variants/badge.svg
+[coveralls-url]: https://coveralls.io/github/NikolayMakhonin/test-variants

package/dist/browser/browser.js

@@ -0,0 +1,24 @@
+!function(r){"use strict";function t(r,t){
+return function(n){
+var e=Object.keys(n),o=Object.values(n),c=e.length,f={}
+;function u(r){var t=o[r]
+;return"function"==typeof t&&(t=t(f)),t}
+for(var a=[],i=[],s=0;s<c;s++)a[s]=-1,i[s]=[]
+;function v(){for(var r=c-1;r>=0;r--){var t=a[r]+1
+;if(t<i[r].length){
+for(a[r]=t,f[e[r]]=i[r][t],r++;r<c;r++){var n=u(r)
+;if(0===n.length)break;a[r]=0,i[r]=n,f[e[r]]=n[0]}
+if(r>=c)return!0}}return!1}i[0]=u(0);var l=0
+;function h(t){
+console.error(JSON.stringify(f,null,2)),console.error(t)
+;var n=Date.now()
+;if(Date.now()-n>5)for(var e=0;e<5;e++)try{r(f)
+}catch(r){}throw t}return function n(){
+for(;v();)try{l++;var e=r(f)
+;if(e&&"function"==typeof e.then)return t&&h(new Error("Unexpected Promise result for sync test function")),
+e.then(n).catch(h)}catch(r){h(r)}return l}()}}
+r.createTestVariants=function(r){return t(r,!1)
+},r.createTestVariantsSync=function(r){
+return t(r,!0)
+},Object.defineProperty(r,"__esModule",{value:!0})
+}({});

package/dist/node/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var testVariants_createTestVariants = require('./test-variants/createTestVariants.cjs');
+
+
+
+exports.createTestVariants = testVariants_createTestVariants.createTestVariants;
+exports.createTestVariantsSync = testVariants_createTestVariants.createTestVariantsSync;

package/dist/node/index.d.ts

@@ -0,0 +1 @@
+export { createTestVariantsSync, createTestVariants, } from './test-variants/createTestVariants';

package/dist/node/test-variants/createTestVariants.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable @typescript-eslint/no-shadow */
+function _createTestVariants(test, sync) {
+    return function _testVariants(args) {
+        const argsKeys = Object.keys(args);
+        const argsValues = Object.values(args);
+        const argsLength = argsKeys.length;
+        const variantArgs = {};
+        function getArgValues(nArg) {
+            let argValues = argsValues[nArg];
+            if (typeof argValues === 'function') {
+                argValues = argValues(variantArgs);
+            }
+            return argValues;
+        }
+        const indexes = [];
+        const values = [];
+        for (let nArg = 0; nArg < argsLength; nArg++) {
+            indexes[nArg] = -1;
+            values[nArg] = [];
+        }
+        values[0] = getArgValues(0);
+        function nextVariant() {
+            for (let nArg = argsLength - 1; nArg >= 0; nArg--) {
+                const index = indexes[nArg] + 1;
+                if (index < values[nArg].length) {
+                    indexes[nArg] = index;
+                    variantArgs[argsKeys[nArg]] = values[nArg][index];
+                    for (nArg++; nArg < argsLength; nArg++) {
+                        const argValues = getArgValues(nArg);
+                        if (argValues.length === 0) {
+                            break;
+                        }
+                        indexes[nArg] = 0;
+                        values[nArg] = argValues;
+                        variantArgs[argsKeys[nArg]] = argValues[0];
+                    }
+                    if (nArg >= argsLength) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        let iteration = 0;
+        function onError(err) {
+            console.error(JSON.stringify(variantArgs, null, 2));
+            console.error(err);
+            // rerun failed variant 5 times for debug
+            const time0 = Date.now();
+            // eslint-disable-next-line no-debugger
+            debugger;
+            if (Date.now() - time0 > 5) {
+                for (let i = 0; i < 5; i++) {
+                    try {
+                        test(variantArgs);
+                    }
+                    catch (_a) {
+                        // eslint-disable-next-line no-debugger
+                        debugger;
+                    }
+                }
+            }
+            throw err;
+        }
+        const next = function next() {
+            while (nextVariant()) {
+                try {
+                    iteration++;
+                    const promise = test(variantArgs);
+                    if (promise && typeof promise.then === 'function') {
+                        if (sync) {
+                            onError(new Error('Unexpected Promise result for sync test function'));
+                        }
+                        return promise.then(next).catch(onError);
+                    }
+                }
+                catch (err) {
+                    onError(err);
+                }
+            }
+            return iteration;
+        };
+        return next();
+    };
+}
+function createTestVariantsSync(test) {
+    return _createTestVariants(test, true);
+}
+function createTestVariants(test) {
+    return _createTestVariants(test, false);
+}
+
+exports.createTestVariants = createTestVariants;
+exports.createTestVariantsSync = createTestVariantsSync;

package/dist/node/test-variants/createTestVariants.d.ts

@@ -0,0 +1,11 @@
+declare type VariantsArgs<TArgs> = {
+    [key in keyof TArgs]: TArgs[key][] | ((args: TArgs) => TArgs[key][]);
+};
+declare type TestVariantsFunc<TArgs, TResult> = <TAdditionalArgs>(args: VariantsArgs<{
+    [key in (keyof TAdditionalArgs | keyof TArgs)]: key extends keyof TArgs ? TArgs[key] : key extends keyof TAdditionalArgs ? TAdditionalArgs[key] : never;
+}>) => TResult;
+export declare type TestVariantsFuncSync<TArgs> = TestVariantsFunc<TArgs, number>;
+export declare type TestVariantsFuncAsync<TArgs> = TestVariantsFunc<TArgs, Promise<number> | number>;
+export declare function createTestVariantsSync<TArgs extends object>(test: (args: TArgs) => void): TestVariantsFuncSync<TArgs>;
+export declare function createTestVariants<TArgs extends object>(test: (args: TArgs) => Promise<void> | void): TestVariantsFuncAsync<TArgs>;
+export {};

package/dist/node/test-variants/createTestVariants.perf.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var rdtsc = require('rdtsc');
+var testVariants_createTestVariants = require('./createTestVariants.cjs');
+
+describe('test > testVariants perf', function () {
+    this.timeout(300000);
+    it('sync/async', function () {
+        const testVariantsAsync = testVariants_createTestVariants.createTestVariants(({ a, b, c }) => {
+        });
+        const testVariantsSync = testVariants_createTestVariants.createTestVariantsSync(({ a, b, c }) => {
+        });
+        const args = {
+            a: [1, 2],
+            b: ['3', '4'],
+            c: [true, false],
+        };
+        const result = rdtsc.calcPerformance(10000, () => {
+        }, () => {
+            testVariantsSync(args);
+        }, () => {
+            testVariantsAsync(args);
+        });
+        const count = testVariantsSync(args);
+        result.absoluteDiff = result.absoluteDiff.map(o => o / count);
+        console.log('testVariants perf:', result);
+    });
+});

package/dist/node/test-variants/createTestVariants.perf.d.ts

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

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@flemist/test-variants",
+  "version": "0.0.0",
+  "description": "Runs a test function with all possible combinations of its parameters.",
+  "main": "dist/node/index.cjs",
+  "types": "dist/node/index.d.ts",
+  "engines": {
+    "yarn": "^1.22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NikolayMakhonin/test-variants.git"
+  },
+  "keywords": [
+    "test",
+    "variants",
+    "combinations",
+    "enumeration",
+    "helper"
+  ],
+  "author": "NikolayMakhonin",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/NikolayMakhonin/test-variants/issues"
+  },
+  "homepage": "https://github.com/NikolayMakhonin/test-variants#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "yarn build && yarn run test:mocha:ci && yarn run test:karma",
+    "lint": "eslint \"./src/**/*.{ts,js,cjs,mjs}\"",
+    "lint:fix": "eslint --fix \"./src/**/*.{ts,js,cjs,mjs}\"",
+    "build:js": "rollup -c && cpy \"**/assets/**\" \"../dist/\" --parents --cwd=src",
+    "build:types": "tsc --outDir dist/node --declaration",
+    "build": "rimraf dist && yarn run build:js && yarn run build:types",
+    "coverage:merge": "rimraf tmp/coverage/{all,merge} && cp-flat \"tmp/coverage/*/json/**/*.json\" \"tmp/coverage/merge\" && nyc report -r lcov --report-dir tmp/coverage/all/lcov --temp-dir \"tmp/coverage/merge/\"",
+    "coverage:check": "yarn run coverage:merge && nyc check-coverage --report-dir tmp/coverage/all/lcov --lines 50 --functions 50 --branches 50 --statements 50",
+    "test:mocha": "mocha ./src/**/*.test.ts",
+    "test:mocha:coverage": "rimraf tmp/coverage/mocha && nyc --all mocha ./src/**/*.test.ts",
+    "test:mocha:watch": "mocha --watch ./src/**/*.test.ts",
+    "test:karma": "rimraf tmp/coverage/karma && karma start --single-run --log-level debug",
+    "test:mocha:ci": "rimraf tmp/coverage/mocha && nyc --all mocha ./src/**/*.test.ts ./dist/**/*.test.cjs",
+    "coveralls": "yarn run coverage:check && nyc report --reporter=text-lcov --temp-dir \"tmp/coverage/merge/\" | coveralls"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.18.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-classes": "^7.17.12",
+    "@babel/plugin-transform-runtime": "^7.18.0",
+    "@babel/preset-env": "^7.18.0",
+    "@babel/runtime-corejs3": "^7.18.0",
+    "@flemist/copy-glob-flat": "^0.0.5",
+    "@flemist/karma-custom-launcher": "^0.0.0",
+    "@rollup/plugin-alias": "^3.1.9",
+    "@rollup/plugin-babel": "^5.3.1",
+    "@rollup/plugin-commonjs": "^21.0.3",
+    "@rollup/plugin-inject": "^4.0.4",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-multi-entry": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-replace": "^4.0.0",
+    "@rollup/plugin-typescript": "^8.3.1",
+    "@types/assert": "^1.5.6",
+    "@types/fs-extra": "^9.0.13",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^17.0.23",
+    "@typescript-eslint/eslint-plugin": "^5.17.0",
+    "@typescript-eslint/parser": "^5.17.0",
+    "cpy-cli": "^3.1.1",
+    "eslint": "^8.12.0",
+    "eslint-config-pro": "^2.1.1",
+    "fs-extra": "^10.0.1",
+    "globby": "^11.1.0",
+    "karma": "^6.3.20",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-coverage": "^2.2.0",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-mocha": "^2.0.1",
+    "karma-safari-launcher": "^1.0.0",
+    "mocha": "^9.2.2",
+    "nodemon": "^2.0.15",
+    "nyc": "^15.1.0",
+    "rdtsc": "^2.0.0",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.70.1",
+    "rollup-plugin-delete": "^2.0.0",
+    "rollup-plugin-istanbul": "^3.0.0",
+    "rollup-plugin-multi-input": "^1.3.1",
+    "rollup-plugin-node-polyfills": "^0.2.1",
+    "rollup-plugin-terser": "^7.0.2",
+    "ts-node": "^10.7.0",
+    "tsconfig-paths": "^3.14.1",
+    "typescript": "^4.6.4"
+  },
+  "dependencies": {
+    "tslib": "^2.3.1"
+  }
+}