@flemist/test-variants 1.0.7 → 2.0.0

package/dist/lib/index.cjs

@@ -2,13 +2,21 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var testVariants_saveErrorVariants = require('./test-variants/saveErrorVariants.cjs');
 var testVariants_createTestVariants = require('./test-variants/createTestVariants.cjs');
 require('tslib');
-require('./garbage-collect/garbageCollect.cjs');
+require('fs');
+require('path');
+require('./test-variants/testVariantsIterable.cjs');
+require('./test-variants/testVariantsCreateTestRun.cjs');
+require('@flemist/async-utils');
+require('./test-variants/argsToString.cjs');
+require('./test-variants/testVariantsRun.cjs');
 require('@flemist/abort-controller-fast');
 require('@flemist/time-limits');
-require('@flemist/async-utils');
+require('./garbage-collect/garbageCollect.cjs');
 
 
 
+exports.generateErrorVariantFilePath = testVariants_saveErrorVariants.generateErrorVariantFilePath;
 exports.createTestVariants = testVariants_createTestVariants.createTestVariants;

package/dist/lib/index.d.ts

@@ -1,2 +1,6 @@
-export type { VariantsArgs, TestVariantsSetArgs, TestVariantsCall, TestVariantsCallParams } from './test-variants/createTestVariants';
-export { createTestVariants } from './test-variants/createTestVariants';
+export { type Obj, type GenerateErrorVariantFilePathOptions, type SaveErrorVariantsOptions, } from "./test-variants/types";
+export { generateErrorVariantFilePath, } from "./test-variants/saveErrorVariants";
+export { type TestVariantsTemplate, type TestVariantsTemplates, type TestVariantsTemplatesExt, } from "./test-variants/testVariantsIterable";
+export { type ErrorEvent, type OnErrorCallback, type TestVariantsTest, type TestVariantsTestResult, type TestVariantsCreateTestRunOptions, type TestVariantsTestRun, type TestVariantsTestRunResult, } from "./test-variants/testVariantsCreateTestRun";
+export { type TestVariantsFindBestErrorOptions, type TestVariantsRunOptions, type TestVariantsBestError, type TestVariantsRunResult, } from "./test-variants/testVariantsRun";
+export { type TestVariantsSetArgs, type TestVariantsCall, createTestVariants, } from './test-variants/createTestVariants';

package/dist/lib/index.mjs

@@ -1,6 +1,13 @@
+export { generateErrorVariantFilePath } from './test-variants/saveErrorVariants.mjs';
 export { createTestVariants } from './test-variants/createTestVariants.mjs';
 import 'tslib';
-import './garbage-collect/garbageCollect.mjs';
+import 'fs';
+import 'path';
+import './test-variants/testVariantsIterable.mjs';
+import './test-variants/testVariantsCreateTestRun.mjs';
+import '@flemist/async-utils';
+import './test-variants/argsToString.mjs';
+import './test-variants/testVariantsRun.mjs';
 import '@flemist/abort-controller-fast';
 import '@flemist/time-limits';
-import '@flemist/async-utils';
+import './garbage-collect/garbageCollect.mjs';

package/dist/lib/test-variants/argsToString.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function argsToString(args) {
+    return JSON.stringify(args, (_, value) => {
+        if (value
+            && typeof value === 'object'
+            && !Array.isArray(value)
+            && value.constructor !== Object) {
+            return value + '';
+        }
+        return value;
+    }, 2);
+}
+
+exports.argsToString = argsToString;

package/dist/lib/test-variants/argsToString.d.ts

@@ -0,0 +1,2 @@
+import { Obj } from "./types";
+export declare function argsToString(args: Obj): string;

package/dist/lib/test-variants/argsToString.mjs

@@ -0,0 +1,13 @@
+function argsToString(args) {
+    return JSON.stringify(args, (_, value) => {
+        if (value
+            && typeof value === 'object'
+            && !Array.isArray(value)
+            && value.constructor !== Object) {
+            return value + '';
+        }
+        return value;
+    }, 2);
+}
+
+export { argsToString };

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

@@ -3,201 +3,84 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var garbageCollect_garbageCollect = require('../garbage-collect/garbageCollect.cjs');
-var abortControllerFast = require('@flemist/abort-controller-fast');
-var timeLimits = require('@flemist/time-limits');
-var asyncUtils = require('@flemist/async-utils');
+var testVariants_testVariantsIterable = require('./testVariantsIterable.cjs');
+var testVariants_testVariantsCreateTestRun = require('./testVariantsCreateTestRun.cjs');
+var testVariants_testVariantsRun = require('./testVariantsRun.cjs');
+require('@flemist/async-utils');
+require('./argsToString.cjs');
+require('@flemist/abort-controller-fast');
+require('@flemist/time-limits');
+require('../garbage-collect/garbageCollect.cjs');
+require('./saveErrorVariants.cjs');
+require('fs');
+require('path');
 
-/* eslint-disable @typescript-eslint/no-shadow */
-function isPromiseLike(value) {
-    return typeof value === 'object'
-        && value
-        && typeof value.then === 'function';
-}
 function createTestVariants(test) {
     return function testVariantsArgs(args) {
-        return function testVariantsCall({ GC_Iterations = 1000000, GC_IterationsAsync = 10000, GC_Interval = 1000, logInterval = 5000, logCompleted = true, onError: onErrorCallback = null, abortSignal: abortSignalExternal = null, parallel: _parallel, } = {}) {
-            const abortControllerParallel = new abortControllerFast.AbortControllerFast();
-            const abortSignalParallel = asyncUtils.combineAbortSignals(abortSignalExternal, abortControllerParallel.signal);
-            const abortSignalAll = abortSignalParallel;
-            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 iterations = 0;
-            let iterationsAsync = 0;
-            let debug = false;
-            let debugIteration = 0;
-            let isNewError = true;
-            function onError(error, iterations, variantArgs) {
-                return tslib.__awaiter(this, void 0, void 0, function* () {
-                    const _isNewError = isNewError;
-                    isNewError = false;
-                    if (_isNewError) {
-                        abortControllerParallel.abort(error);
-                        console.error(`error variant: ${iterations}\r\n${JSON.stringify(variantArgs, (_, value) => {
-                            if (value
-                                && typeof value === 'object'
-                                && !Array.isArray(value)
-                                && value.constructor !== Object) {
-                                return value + '';
-                            }
-                            return value;
-                        }, 2)}`);
-                        console.error(error);
-                    }
-                    // rerun failed variant 5 times for debug
-                    const time0 = Date.now();
-                    // eslint-disable-next-line no-debugger
-                    debugger;
-                    if (Date.now() - time0 > 50 && debugIteration < 5) {
-                        console.log('DEBUG ITERATION: ' + debugIteration);
-                        debug = true;
-                        yield next();
-                        debugIteration++;
-                    }
-                    if (_isNewError) {
-                        if (onErrorCallback) {
-                            onErrorCallback({
-                                iteration: iterations,
-                                variant: variantArgs,
-                                error,
-                            });
-                        }
-                        throw error;
-                    }
-                });
-            }
-            function onCompleted() {
-                if (logCompleted) {
-                    console.log('variants: ' + iterations);
-                }
-            }
-            let prevLogTime = Date.now();
-            let prevGC_Time = prevLogTime;
-            let prevGC_Iterations = iterations;
-            let prevGC_IterationsAsync = iterationsAsync;
-            const parallel = _parallel === true
-                ? Math.pow(2, 31)
-                : !_parallel || _parallel <= 0
-                    ? 1
-                    : _parallel;
-            const pool = parallel <= 1
-                ? null
-                : new timeLimits.Pool(parallel);
-            function runTest(_iterations, variantArgs, abortSignal) {
-                return tslib.__awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const promiseOrIterations = test(variantArgs, abortSignal);
-                        if (isPromiseLike(promiseOrIterations)) {
-                            const value = yield promiseOrIterations;
-                            const newIterations = typeof value === 'number' ? value : 1;
-                            iterationsAsync += newIterations;
-                            iterations += newIterations;
-                            return;
-                        }
-                        iterations += typeof promiseOrIterations === 'number' ? promiseOrIterations : 1;
-                    }
-                    catch (err) {
-                        yield onError(err, _iterations, variantArgs);
-                    }
+        return function testVariantsCall(options) {
+            return tslib.__awaiter(this, void 0, void 0, function* () {
+                const testRun = testVariants_testVariantsCreateTestRun.testVariantsCreateTestRun(test, {
+                    onError: options === null || options === void 0 ? void 0 : options.onError,
                 });
-            }
-            function next() {
-                return tslib.__awaiter(this, void 0, void 0, function* () {
-                    while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || nextVariant())) {
-                        const _iterations = iterations;
-                        const _variantArgs = !pool
-                            ? variantArgs
-                            : Object.assign({}, variantArgs);
-                        const now = (logInterval || GC_Interval) && Date.now();
-                        if (logInterval && now - prevLogTime >= logInterval) {
-                            // the log is required to prevent the karma browserNoActivityTimeout
-                            console.log(iterations);
-                            prevLogTime = now;
-                        }
-                        if (GC_Iterations && iterations - prevGC_Iterations >= GC_Iterations
-                            || GC_IterationsAsync && iterationsAsync - prevGC_IterationsAsync >= GC_IterationsAsync
-                            || GC_Interval && now - prevGC_Time >= GC_Interval) {
-                            prevGC_Iterations = iterations;
-                            prevGC_IterationsAsync = iterationsAsync;
-                            prevGC_Time = now;
-                            yield garbageCollect_garbageCollect.garbageCollect(1);
-                        }
-                        if (abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) {
-                            continue;
-                        }
-                        if (!pool || abortSignalParallel.aborted) {
-                            yield runTest(_iterations, _variantArgs, abortSignalExternal);
-                        }
-                        else {
-                            if (!pool.hold(1)) {
-                                yield pool.holdWait(1);
-                            }
-                            void (() => tslib.__awaiter(this, void 0, void 0, function* () {
-                                try {
-                                    if (abortSignalParallel === null || abortSignalParallel === void 0 ? void 0 : abortSignalParallel.aborted) {
-                                        return;
-                                    }
-                                    yield runTest(_iterations, _variantArgs, abortSignalParallel);
-                                }
-                                finally {
-                                    void pool.release(1);
-                                }
-                            }))();
-                        }
-                    }
-                    if (pool) {
-                        yield pool.holdWait(parallel);
-                        void pool.release(parallel);
-                    }
-                    if (abortSignalAll === null || abortSignalAll === void 0 ? void 0 : abortSignalAll.aborted) {
-                        throw abortSignalAll.reason;
-                    }
-                    onCompleted();
-                    yield garbageCollect_garbageCollect.garbageCollect(1);
-                    return iterations;
+                const variants = testVariants_testVariantsIterable.testVariantsIterable({
+                    argsTemplates: args,
                 });
-            }
-            return next();
+                return testVariants_testVariantsRun.testVariantsRun(testRun, variants, options);
+            });
         };
     };
 }
+/*
+export class TestVariants<Args extends Obj> {
+  private readonly _test: TestVariantsTest<Args>
+  test(args: Args, abortSignal: IAbortSignalFast) {
+    return this._test(args, abortSignal)
+  }
+
+  constructor(
+    test: TestVariantsTest<Args>,
+  ) {
+    this.test = test
+  }
+
+  createVariants<ArgsExtra extends Obj>(
+    argsTemplates: TestVariantsTemplatesExt<Args, ArgsExtra>,
+  ): Iterable<Args> {
+    return testVariantsIterable<Args, ArgsExtra>(argsTemplates)
+  }
+
+  createTestRun(
+    options?: null | TestVariantsCreateTestRunOptions<Args>,
+  ) {
+    return testVariantsCreateTestRun<Args>(this._test, options)
+  }
+
+  testAll<ArgsExtra extends Obj>(
+    argsTemplates: TestVariantsTemplatesExt<Args, ArgsExtra>,
+  ): TestVariantsCall<Args>
+  testAll(
+    variants: Iterable<Args>,
+  ): TestVariantsCall<Args>
+  testAll<ArgsExtra extends Obj>(
+    variantsOrTemplates: Iterable<Args> | TestVariantsTemplatesExt<Args, ArgsExtra>,
+  ): TestVariantsCall<Args> {
+    const variants = Symbol.iterator in variantsOrTemplates
+      ? variantsOrTemplates as Iterable<Args>
+      : this.createVariants(variantsOrTemplates as TestVariantsTemplatesExt<Args, ArgsExtra>)
+
+    const _this = this
+
+    return function testVariantsCall(
+      options?: null | TestVariantsRunOptions & TestVariantsCreateTestRunOptions<Args>,
+    ) {
+      const testRun = _this.createTestRun({
+        onError: options?.onError,
+      })
+
+      return testVariantsRun<Args>(testRun, variants, options)
+    }
+  }
+}
+*/
 
 exports.createTestVariants = createTestVariants;

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

@@ -1,30 +1,8 @@
-import { IAbortSignalFast } from '@flemist/abort-controller-fast';
-export declare type VariantsArgs<TArgs> = {
-    [key in keyof TArgs]: TArgs[key][] | ((args: TArgs) => TArgs[key][]);
-};
-declare type PromiseOrValue<T> = Promise<T> | T;
-export declare type TestVariantsCall<TArgs> = (callParams?: TestVariantsCallParams<TArgs>) => PromiseOrValue<number>;
-export declare type TestVariantsSetArgs<TArgs> = <TAdditionalArgs>(args: VariantsArgs<{
-    [key in (keyof TAdditionalArgs | keyof TArgs)]: key extends keyof TArgs ? TArgs[key] : key extends keyof TAdditionalArgs ? TAdditionalArgs[key] : never;
-}>) => TestVariantsCall<TArgs>;
-export declare type TestVariantsCallParams<TArgs> = {
-    /** Wait for garbage collection after iterations */
-    GC_Iterations?: number;
-    /** Same as GC_Iterations but only for async test variants, required for 10000 and more of Promise rejections */
-    GC_IterationsAsync?: number;
-    /** Wait for garbage collection after time interval, required to prevent the karma browserDisconnectTimeout */
-    GC_Interval?: number;
-    /** console log current iterations, required to prevent the karma browserNoActivityTimeout */
-    logInterval?: number;
-    /** console log iterations on test completed */
-    logCompleted?: boolean;
-    onError?: (event: {
-        iteration: number;
-        variant: TArgs;
-        error: any;
-    }) => void;
-    abortSignal?: IAbortSignalFast;
-    parallel?: null | number | boolean;
-};
-export declare function createTestVariants<TArgs extends object>(test: (args: TArgs, abortSignal: IAbortSignalFast) => Promise<number | void> | number | void): TestVariantsSetArgs<TArgs>;
-export {};
+import { type PromiseOrValue } from '@flemist/async-utils';
+import { TestVariantsTemplatesExt } from "./testVariantsIterable";
+import { TestVariantsCreateTestRunOptions, TestVariantsTest } from "./testVariantsCreateTestRun";
+import { TestVariantsRunOptions, TestVariantsRunResult } from "./testVariantsRun";
+import { Obj } from "./types";
+export declare type TestVariantsCall<Args extends Obj> = <SavedArgs = Args>(options?: null | TestVariantsRunOptions<Args, SavedArgs> & TestVariantsCreateTestRunOptions<Args>) => PromiseOrValue<TestVariantsRunResult<Args>>;
+export declare type TestVariantsSetArgs<Args extends Obj> = <ArgsExtra extends Obj>(args: TestVariantsTemplatesExt<Omit<Args, 'seed'>, Omit<ArgsExtra, 'seed'>>) => TestVariantsCall<Args>;
+export declare function createTestVariants<Args extends Obj>(test: TestVariantsTest<Args>): TestVariantsSetArgs<Args>;