@flemist/test-variants 2.0.5 → 3.0.0

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

@@ -48,23 +48,11 @@ function testVariantsRun(testRun, variants, options = {}) {
     return tslib.__awaiter(this, void 0, void 0, function* () {
         const saveErrorVariants = options.saveErrorVariants;
         const retriesPerVariant = (_a = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.retriesPerVariant) !== null && _a !== void 0 ? _a : 1;
+        const useToFindBestError = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.useToFindBestError;
         const sessionDate = new Date();
         const errorVariantFilePath = saveErrorVariants
             ? path__namespace.resolve(saveErrorVariants.dir, (_c = (_b = saveErrorVariants.getFilePath) === null || _b === void 0 ? void 0 : _b.call(saveErrorVariants, { sessionDate })) !== null && _c !== void 0 ? _c : testVariants_saveErrorVariants.generateErrorVariantFilePath({ sessionDate }))
             : null;
-        // Replay phase: run previously saved error variants before normal iteration
-        if (saveErrorVariants) {
-            const files = yield testVariants_saveErrorVariants.readErrorVariantFiles(saveErrorVariants.dir);
-            for (const filePath of files) {
-                const args = yield testVariants_saveErrorVariants.parseErrorVariantFile(filePath, saveErrorVariants.jsonToArgs);
-                for (let retry = 0; retry < retriesPerVariant; retry++) {
-                    const promiseOrResult = testRun(args, -1, null);
-                    if (asyncUtils.isPromiseLike(promiseOrResult)) {
-                        yield promiseOrResult;
-                    }
-                }
-            }
-        }
         const GC_Iterations = (_d = options.GC_Iterations) !== null && _d !== void 0 ? _d : 1000000;
         const GC_IterationsAsync = (_e = options.GC_IterationsAsync) !== null && _e !== void 0 ? _e : 10000;
         const GC_Interval = (_f = options.GC_Interval) !== null && _f !== void 0 ? _f : 1000;
@@ -72,85 +60,47 @@ function testVariantsRun(testRun, variants, options = {}) {
         const logCompleted = (_h = options.logCompleted) !== null && _h !== void 0 ? _h : true;
         const abortSignalExternal = options.abortSignal;
         const findBestError = options.findBestError;
+        const cycles = (_j = findBestError === null || findBestError === void 0 ? void 0 : findBestError.cycles) !== null && _j !== void 0 ? _j : 1;
         const parallel = options.parallel === true
             ? Math.pow(2, 31)
             : !options.parallel || options.parallel <= 0
                 ? 1
                 : options.parallel;
-        const limitVariantsCount = (_j = options.limitVariantsCount) !== null && _j !== void 0 ? _j : null;
-        let prevCycleVariantsCount = null;
-        let prevCycleDuration = null;
-        let cycleIndex = 0;
-        let repeatIndex = 0;
-        const startTime = Date.now();
-        let cycleStartTime = startTime;
-        let seed = void 0;
-        let bestError = null;
-        let index = -1;
-        let args = {};
-        let variantsIterator = variants[Symbol.iterator]();
-        function getLimitVariantsCount() {
-            if (limitVariantsCount != null && bestError != null) {
-                return Math.min(limitVariantsCount, bestError.index);
-            }
-            if (limitVariantsCount != null) {
-                return limitVariantsCount;
-            }
-            if (bestError != null) {
-                return bestError.index;
-            }
-            return null;
+        // Apply initial limits
+        if (options.limitVariantsCount != null) {
+            variants.addLimit({ index: options.limitVariantsCount });
         }
-        function nextVariant() {
-            while (true) {
-                // Try next repeat for current variant
-                if (findBestError && index >= 0 && (bestError == null || index < bestError.index)) {
-                    repeatIndex++;
-                    if (repeatIndex < findBestError.repeatsPerVariant) {
-                        seed = findBestError.getSeed({
-                            variantIndex: index,
-                            cycleIndex,
-                            repeatIndex,
-                            totalIndex: cycleIndex * findBestError.repeatsPerVariant + repeatIndex,
-                        });
-                        return true;
+        // Replay phase: run previously saved error variants before normal iteration
+        if (saveErrorVariants) {
+            const files = yield testVariants_saveErrorVariants.readErrorVariantFiles(saveErrorVariants.dir);
+            for (const filePath of files) {
+                const args = yield testVariants_saveErrorVariants.parseErrorVariantFile(filePath, saveErrorVariants.jsonToArgs);
+                for (let retry = 0; retry < retriesPerVariant; retry++) {
+                    try {
+                        const promiseOrResult = testRun(args, -1, null);
+                        if (asyncUtils.isPromiseLike(promiseOrResult)) {
+                            yield promiseOrResult;
+                        }
                     }
-                }
-                repeatIndex = 0;
-                index++;
-                if (findBestError && cycleIndex >= findBestError.cycles) {
-                    return false;
-                }
-                const _limitVariantsCount = getLimitVariantsCount();
-                if (_limitVariantsCount == null || index < _limitVariantsCount) {
-                    const result = variantsIterator.next();
-                    if (!result.done) {
-                        args = result.value;
-                        if (findBestError) {
-                            seed = findBestError.getSeed({
-                                variantIndex: index,
-                                cycleIndex,
-                                repeatIndex,
-                                totalIndex: cycleIndex * findBestError.repeatsPerVariant + repeatIndex,
-                            });
+                    catch (error) {
+                        if (useToFindBestError && findBestError) {
+                            // Store as pending limit for findBestError cycle
+                            variants.addLimit({ args, error });
+                            break; // Exit retry loop, continue to next file
+                        }
+                        else {
+                            throw error;
                         }
-                        return true;
                     }
                 }
-                if (!findBestError) {
-                    return false;
-                }
-                prevCycleVariantsCount = index;
-                prevCycleDuration = Date.now() - cycleStartTime;
-                cycleIndex++;
-                cycleStartTime = Date.now();
-                if (cycleIndex >= findBestError.cycles) {
-                    return false;
-                }
-                index = -1;
-                variantsIterator = variants[Symbol.iterator]();
+                // If no error occurred during replays, the saved variant is no longer reproducible
+                // (templates may have changed) - silently skip
             }
         }
+        let prevCycleVariantsCount = null;
+        let prevCycleDuration = null;
+        const startTime = Date.now();
+        let cycleStartTime = startTime;
         const abortControllerParallel = new abortControllerFast.AbortControllerFast();
         const abortSignalParallel = asyncUtils.combineAbortSignals(abortSignalExternal, abortControllerParallel.signal);
         const abortSignalAll = abortSignalParallel;
@@ -166,67 +116,105 @@ function testVariantsRun(testRun, variants, options = {}) {
             : new timeLimits.Pool(parallel);
         function onCompleted() {
             if (logCompleted) {
-                console.log(`[test-variants] variants: ${index}, iterations: ${iterations}, async: ${iterationsAsync}`);
+                console.log(`[test-variants] variants: ${variants.index}, iterations: ${iterations}, async: ${iterationsAsync}`);
             }
         }
-        function next() {
-            return tslib.__awaiter(this, void 0, void 0, function* () {
-                while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || nextVariant())) {
-                    const _index = index;
-                    const _args = Object.assign(Object.assign({}, args), { seed });
-                    const now = (logInterval || GC_Interval) && Date.now();
-                    if (logInterval && now - prevLogTime >= logInterval) {
-                        // the log is required to prevent the karma browserNoActivityTimeout
-                        let log = '';
-                        const cycleElapsed = now - cycleStartTime;
-                        const totalElapsed = now - startTime;
-                        if (findBestError) {
-                            log += `cycle: ${cycleIndex}, variant: ${index}`;
-                            let max = getLimitVariantsCount();
-                            if (max != null) {
-                                if (prevCycleVariantsCount != null && prevCycleVariantsCount < max) {
-                                    max = prevCycleVariantsCount;
-                                }
+        // Main iteration using iterator
+        variants.start();
+        while (variants.cycleIndex < cycles) {
+            let args;
+            while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || (args = variants.next()) != null)) {
+                const _index = variants.index;
+                const _args = args;
+                const now = (logInterval || GC_Interval) && Date.now();
+                if (logInterval && now - prevLogTime >= logInterval) {
+                    // the log is required to prevent the karma browserNoActivityTimeout
+                    let log = '';
+                    const cycleElapsed = now - cycleStartTime;
+                    const totalElapsed = now - startTime;
+                    if (findBestError) {
+                        log += `cycle: ${variants.cycleIndex}, variant: ${variants.index}`;
+                        let max = variants.count;
+                        if (max != null) {
+                            if (prevCycleVariantsCount != null && prevCycleVariantsCount < max) {
+                                max = prevCycleVariantsCount;
                             }
-                            if (max != null && index > 0) {
-                                let estimatedCycleTime;
-                                if (prevCycleDuration != null && prevCycleVariantsCount != null
-                                    && index < prevCycleVariantsCount && cycleElapsed < prevCycleDuration) {
-                                    const adjustedDuration = prevCycleDuration - cycleElapsed;
-                                    const adjustedCount = prevCycleVariantsCount - index;
-                                    const speedForRemaining = adjustedDuration / adjustedCount;
-                                    const remainingTime = (max - index) * speedForRemaining;
-                                    estimatedCycleTime = cycleElapsed + remainingTime;
-                                }
-                                else {
-                                    estimatedCycleTime = cycleElapsed * max / index;
-                                }
-                                log += `/${max} (${formatDuration(cycleElapsed)}/${formatDuration(estimatedCycleTime)})`;
+                        }
+                        if (max != null && variants.index > 0) {
+                            let estimatedCycleTime;
+                            if (prevCycleDuration != null && prevCycleVariantsCount != null
+                                && variants.index < prevCycleVariantsCount && cycleElapsed < prevCycleDuration) {
+                                const adjustedDuration = prevCycleDuration - cycleElapsed;
+                                const adjustedCount = prevCycleVariantsCount - variants.index;
+                                const speedForRemaining = adjustedDuration / adjustedCount;
+                                const remainingTime = (max - variants.index) * speedForRemaining;
+                                estimatedCycleTime = cycleElapsed + remainingTime;
                             }
                             else {
-                                log += ` (${formatDuration(cycleElapsed)})`;
+                                estimatedCycleTime = cycleElapsed * max / variants.index;
                             }
+                            log += `/${max} (${formatDuration(cycleElapsed)}/${formatDuration(estimatedCycleTime)})`;
                         }
                         else {
-                            log += `variant: ${index} (${formatDuration(cycleElapsed)})`;
+                            log += ` (${formatDuration(cycleElapsed)})`;
+                        }
+                    }
+                    else {
+                        log += `variant: ${variants.index} (${formatDuration(cycleElapsed)})`;
+                    }
+                    log += `, total: ${iterations} (${formatDuration(totalElapsed)})`;
+                    console.log(log);
+                    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) {
+                    try {
+                        let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
+                        if (asyncUtils.isPromiseLike(promiseOrIterations)) {
+                            promiseOrIterations = yield promiseOrIterations;
+                        }
+                        if (!promiseOrIterations) {
+                            debug = true;
+                            abortControllerParallel.abort();
+                            continue;
                         }
-                        log += `, total: ${iterations} (${formatDuration(totalElapsed)})`;
-                        console.log(log);
-                        prevLogTime = now;
+                        const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
+                        iterationsAsync += _iterationsAsync;
+                        iterations += _iterationsSync + _iterationsAsync;
                     }
-                    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);
+                    catch (err) {
+                        if (errorVariantFilePath) {
+                            yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                        }
+                        if (findBestError) {
+                            variants.addLimit({ error: err });
+                            debug = false;
+                        }
+                        else {
+                            throw err;
+                        }
                     }
-                    if (abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) {
-                        continue;
+                }
+                else {
+                    if (!pool.hold(1)) {
+                        yield pool.holdWait(1);
                     }
-                    if (!pool || abortSignalParallel.aborted) {
+                    // eslint-disable-next-line @typescript-eslint/no-loop-func
+                    void (() => tslib.__awaiter(this, void 0, void 0, function* () {
                         try {
+                            if (abortSignalParallel === null || abortSignalParallel === void 0 ? void 0 : abortSignalParallel.aborted) {
+                                return;
+                            }
                             let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
                             if (asyncUtils.isPromiseLike(promiseOrIterations)) {
                                 promiseOrIterations = yield promiseOrIterations;
@@ -234,7 +222,7 @@ function testVariantsRun(testRun, variants, options = {}) {
                             if (!promiseOrIterations) {
                                 debug = true;
                                 abortControllerParallel.abort();
-                                continue;
+                                return;
                             }
                             const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
                             iterationsAsync += _iterationsAsync;
@@ -245,78 +233,44 @@ function testVariantsRun(testRun, variants, options = {}) {
                                 yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
                             }
                             if (findBestError) {
-                                bestError = {
-                                    error: err,
-                                    args: _args,
-                                    index: _index,
-                                };
+                                variants.addLimit({ error: err });
                                 debug = false;
                             }
                             else {
                                 throw err;
                             }
                         }
-                    }
-                    else {
-                        if (!pool.hold(1)) {
-                            yield pool.holdWait(1);
+                        finally {
+                            void pool.release(1);
                         }
-                        // eslint-disable-next-line @typescript-eslint/no-loop-func
-                        void (() => tslib.__awaiter(this, void 0, void 0, function* () {
-                            try {
-                                if (abortSignalParallel === null || abortSignalParallel === void 0 ? void 0 : abortSignalParallel.aborted) {
-                                    return;
-                                }
-                                let promiseOrIterations = testRun(_args, _index, abortSignalParallel);
-                                if (asyncUtils.isPromiseLike(promiseOrIterations)) {
-                                    promiseOrIterations = yield promiseOrIterations;
-                                }
-                                if (!promiseOrIterations) {
-                                    debug = true;
-                                    abortControllerParallel.abort();
-                                    return;
-                                }
-                                const { iterationsAsync: _iterationsAsync, iterationsSync: _iterationsSync } = promiseOrIterations;
-                                iterationsAsync += _iterationsAsync;
-                                iterations += _iterationsSync + _iterationsAsync;
-                            }
-                            catch (err) {
-                                if (errorVariantFilePath) {
-                                    yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
-                                }
-                                if (findBestError) {
-                                    bestError = {
-                                        error: err,
-                                        args: _args,
-                                        index: _index,
-                                    };
-                                    debug = false;
-                                }
-                                else {
-                                    throw err;
-                                }
-                            }
-                            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;
-            });
+            }
+            // Track cycle metrics for logging
+            prevCycleVariantsCount = variants.count;
+            prevCycleDuration = Date.now() - cycleStartTime;
+            cycleStartTime = Date.now();
+            variants.start();
         }
-        const result = yield next();
+        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);
+        // Construct bestError from iterator state
+        const bestError = variants.limit
+            ? {
+                error: variants.limit.error,
+                args: variants.limit.args,
+                index: variants.count,
+            }
+            : null;
         return {
-            iterations: result,
+            iterations,
             bestError,
         };
     });

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

@@ -1,25 +1,15 @@
 import { TestVariantsTestRun } from './testVariantsCreateTestRun';
 import { type IAbortSignalFast } from '@flemist/abort-controller-fast';
 import { Obj, type SaveErrorVariantsOptions } from "./types";
-/** Parameters passed to getSeed function for generating test seeds */
-export declare type GetSeedParams = {
-    /** Index of current variant/parameter-combination being tested */
-    variantIndex: number;
-    /** Index of current cycle - full pass through all variants (0..cycles-1) */
-    cycleIndex: number;
-    /** Index of repeat for current variant within this cycle (0..repeatsPerVariant-1) */
-    repeatIndex: number;
-    /** Total index across all cycles: cycleIndex × repeatsPerVariant + repeatIndex */
-    totalIndex: number;
-};
+import { TestVariantsIterator, type GetSeedParams } from './testVariantsIterator';
 /** Options for finding the earliest failing variant across multiple test runs */
 export declare type TestVariantsFindBestErrorOptions = {
-    /** Function to generate seed based on current iteration state */
-    getSeed: (params: GetSeedParams) => any;
     /** Number of full passes through all variants */
     cycles: number;
-    /** Number of repeat tests per variant within each cycle */
-    repeatsPerVariant: number;
+    /** Function to generate seed based on current iteration state (passed to iterator) */
+    getSeed?: null | ((params: GetSeedParams) => any);
+    /** Number of repeat tests per variant within each cycle (passed to iterator) */
+    repeatsPerVariant?: null | number;
 };
 export declare type TestVariantsRunOptions<Args extends Obj = Obj, SavedArgs = Args> = {
     /** Wait for garbage collection after iterations */
@@ -49,4 +39,4 @@ export declare type TestVariantsRunResult<Arg extends Obj> = {
     iterations: number;
     bestError: null | TestVariantsBestError<Arg>;
 };
-export declare function testVariantsRun<Args extends Obj, SavedArgs = Args>(testRun: TestVariantsTestRun<Args>, variants: Iterable<Args>, options?: TestVariantsRunOptions<Args, SavedArgs>): Promise<TestVariantsRunResult<Args>>;
+export declare function testVariantsRun<Args extends Obj, SavedArgs = Args>(testRun: TestVariantsTestRun<Args>, variants: TestVariantsIterator<Args>, options?: TestVariantsRunOptions<Args, SavedArgs>): Promise<TestVariantsRunResult<Args>>;