@flemist/test-variants 1.0.7 → 2.0.0

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

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+/** Reads saved error variant files from directory, sorted by filename descending (newest first) */
+function readErrorVariantFiles(dir) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        const stat = yield fs__namespace.promises.stat(dir).catch(() => null);
+        if (stat == null) {
+            return [];
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`[saveErrorVariants] path is not a directory: ${dir}`);
+        }
+        const files = yield fs__namespace.promises.readdir(dir);
+        const jsonFiles = files
+            .filter(file => file.endsWith('.json'))
+            .sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
+        return jsonFiles.map(file => path__namespace.join(dir, file));
+    });
+}
+/** Parses saved error variant file and transforms JSON to args */
+function parseErrorVariantFile(filePath, jsonToArgs) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        const content = yield fs__namespace.promises.readFile(filePath, 'utf-8');
+        let json;
+        try {
+            json = JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`[saveErrorVariants] invalid JSON in file: ${filePath}`);
+        }
+        if (jsonToArgs) {
+            try {
+                return jsonToArgs(json);
+            }
+            catch (err) {
+                throw new Error(`[saveErrorVariants] jsonToArgs failed for file: ${filePath}`);
+            }
+        }
+        return json;
+    });
+}
+/** Generates default error variant file path: YYYY-MM-DD_HH-mm-ss.json (UTC) */
+function generateErrorVariantFilePath(options) {
+    return options.sessionDate.toISOString().substring(0, 19).replace('T', '_').replaceAll(':', '-') + '.json';
+}
+/** Saves error-causing args to a JSON file, overwrites if file exists */
+function saveErrorVariantFile(args, filePath, argsToJson) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        let content;
+        if (argsToJson) {
+            const result = argsToJson(args);
+            if (typeof result === 'string') {
+                content = result;
+            }
+            else {
+                content = JSON.stringify(result, null, 2);
+            }
+        }
+        else {
+            content = JSON.stringify(args, null, 2);
+        }
+        yield fs__namespace.promises.mkdir(path__namespace.dirname(filePath), { recursive: true });
+        yield fs__namespace.promises.writeFile(filePath, content, 'utf-8');
+    });
+}
+
+exports.generateErrorVariantFilePath = generateErrorVariantFilePath;
+exports.parseErrorVariantFile = parseErrorVariantFile;
+exports.readErrorVariantFiles = readErrorVariantFiles;
+exports.saveErrorVariantFile = saveErrorVariantFile;

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

@@ -0,0 +1,9 @@
+import { type GenerateErrorVariantFilePathOptions, type Obj } from "./types";
+/** Reads saved error variant files from directory, sorted by filename descending (newest first) */
+export declare function readErrorVariantFiles(dir: string): Promise<string[]>;
+/** Parses saved error variant file and transforms JSON to args */
+export declare function parseErrorVariantFile<Args extends Obj, SavedArgs>(filePath: string, jsonToArgs?: null | ((json: SavedArgs) => Args)): Promise<Args>;
+/** Generates default error variant file path: YYYY-MM-DD_HH-mm-ss.json (UTC) */
+export declare function generateErrorVariantFilePath(options: GenerateErrorVariantFilePathOptions): string;
+/** Saves error-causing args to a JSON file, overwrites if file exists */
+export declare function saveErrorVariantFile<Args extends Obj, SavedArgs>(args: Args, filePath: string, argsToJson?: null | ((args: Args) => string | SavedArgs)): Promise<void>;

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

@@ -0,0 +1,69 @@
+import { __awaiter } from 'tslib';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/** Reads saved error variant files from directory, sorted by filename descending (newest first) */
+function readErrorVariantFiles(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stat = yield fs.promises.stat(dir).catch(() => null);
+        if (stat == null) {
+            return [];
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`[saveErrorVariants] path is not a directory: ${dir}`);
+        }
+        const files = yield fs.promises.readdir(dir);
+        const jsonFiles = files
+            .filter(file => file.endsWith('.json'))
+            .sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
+        return jsonFiles.map(file => path.join(dir, file));
+    });
+}
+/** Parses saved error variant file and transforms JSON to args */
+function parseErrorVariantFile(filePath, jsonToArgs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const content = yield fs.promises.readFile(filePath, 'utf-8');
+        let json;
+        try {
+            json = JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`[saveErrorVariants] invalid JSON in file: ${filePath}`);
+        }
+        if (jsonToArgs) {
+            try {
+                return jsonToArgs(json);
+            }
+            catch (err) {
+                throw new Error(`[saveErrorVariants] jsonToArgs failed for file: ${filePath}`);
+            }
+        }
+        return json;
+    });
+}
+/** Generates default error variant file path: YYYY-MM-DD_HH-mm-ss.json (UTC) */
+function generateErrorVariantFilePath(options) {
+    return options.sessionDate.toISOString().substring(0, 19).replace('T', '_').replaceAll(':', '-') + '.json';
+}
+/** Saves error-causing args to a JSON file, overwrites if file exists */
+function saveErrorVariantFile(args, filePath, argsToJson) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let content;
+        if (argsToJson) {
+            const result = argsToJson(args);
+            if (typeof result === 'string') {
+                content = result;
+            }
+            else {
+                content = JSON.stringify(result, null, 2);
+            }
+        }
+        else {
+            content = JSON.stringify(args, null, 2);
+        }
+        yield fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        yield fs.promises.writeFile(filePath, content, 'utf-8');
+    });
+}
+
+export { generateErrorVariantFilePath, parseErrorVariantFile, readErrorVariantFiles, saveErrorVariantFile };

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

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var asyncUtils = require('@flemist/async-utils');
+var testVariants_argsToString = require('./argsToString.cjs');
+
+function testVariantsCreateTestRun(test, options) {
+    let debugIteration = 0;
+    let errorEvent = null;
+    function onError(error, args, index) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            errorEvent = {
+                error,
+                args,
+                index: index,
+            };
+            console.error(`[test-variants] error variant: ${index}\n${testVariants_argsToString.argsToString(args)}`);
+            console.error(error);
+            // Rerun failed variant 5 times for debug
+            const time0 = Date.now();
+            // Will stop execution right before next error iteration for step-by-step debugging
+            // eslint-disable-next-line no-debugger
+            debugger;
+            if (Date.now() - time0 > 50 && debugIteration < 5) {
+                console.log('[test-variants] DEBUG ITERATION: ' + debugIteration);
+                debugIteration++;
+                return;
+            }
+            if (options.onError) {
+                yield options.onError(errorEvent);
+            }
+            throw errorEvent.error;
+        });
+    }
+    return function testRun(args, index, abortSignal) {
+        try {
+            const promiseOrIterations = test(args, abortSignal);
+            if (asyncUtils.isPromiseLike(promiseOrIterations)) {
+                return promiseOrIterations.then(value => {
+                    if (typeof value === 'number') {
+                        return {
+                            iterationsAsync: value,
+                            iterationsSync: 0,
+                        };
+                    }
+                    if (value !== null && typeof value === 'object') {
+                        return value;
+                    }
+                    return {
+                        iterationsAsync: 1,
+                        iterationsSync: 0,
+                    };
+                }, err => {
+                    return onError(err, args, index);
+                });
+            }
+            const value = promiseOrIterations;
+            if (typeof value === 'number') {
+                return {
+                    iterationsAsync: 0,
+                    iterationsSync: value,
+                };
+            }
+            if (value !== null && typeof value === 'object') {
+                return value;
+            }
+            return {
+                iterationsAsync: 0,
+                iterationsSync: 1,
+            };
+        }
+        catch (err) {
+            return onError(err, args, index);
+        }
+    };
+}
+
+exports.testVariantsCreateTestRun = testVariantsCreateTestRun;

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

@@ -0,0 +1,22 @@
+import { type IAbortSignalFast } from '@flemist/abort-controller-fast';
+import { type PromiseOrValue } from '@flemist/async-utils';
+import { Obj } from "./types";
+export declare type ErrorEvent<Args extends Obj> = {
+    error: any;
+    args: Args;
+    index: number;
+};
+export declare type OnErrorCallback<Args extends Obj> = (event: ErrorEvent<Args>) => PromiseOrValue<void>;
+export declare type TestVariantsCreateTestRunOptions<Args extends Obj> = {
+    onError?: null | OnErrorCallback<Args>;
+};
+export declare type TestVariantsTestRunResult = void | {
+    iterationsAsync: number;
+    iterationsSync: number;
+};
+export declare type TestVariantsTestRun<Args extends Obj> = (args: Args, index: number, abortSignal: IAbortSignalFast) => PromiseOrValue<TestVariantsTestRunResult>;
+export declare type TestVariantsTestResult = number | void | TestVariantsTestRunResult;
+export declare type TestVariantsTest<Args extends Obj> = (args: Args & {
+    seed?: null | number;
+}, abortSignal: IAbortSignalFast) => PromiseOrValue<TestVariantsTestResult>;
+export declare function testVariantsCreateTestRun<Args extends Obj>(test: TestVariantsTest<Args>, options?: null | TestVariantsCreateTestRunOptions<Args>): TestVariantsTestRun<Args>;

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

@@ -0,0 +1,76 @@
+import { __awaiter } from 'tslib';
+import { isPromiseLike } from '@flemist/async-utils';
+import { argsToString } from './argsToString.mjs';
+
+function testVariantsCreateTestRun(test, options) {
+    let debugIteration = 0;
+    let errorEvent = null;
+    function onError(error, args, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            errorEvent = {
+                error,
+                args,
+                index: index,
+            };
+            console.error(`[test-variants] error variant: ${index}\n${argsToString(args)}`);
+            console.error(error);
+            // Rerun failed variant 5 times for debug
+            const time0 = Date.now();
+            // Will stop execution right before next error iteration for step-by-step debugging
+            // eslint-disable-next-line no-debugger
+            debugger;
+            if (Date.now() - time0 > 50 && debugIteration < 5) {
+                console.log('[test-variants] DEBUG ITERATION: ' + debugIteration);
+                debugIteration++;
+                return;
+            }
+            if (options.onError) {
+                yield options.onError(errorEvent);
+            }
+            throw errorEvent.error;
+        });
+    }
+    return function testRun(args, index, abortSignal) {
+        try {
+            const promiseOrIterations = test(args, abortSignal);
+            if (isPromiseLike(promiseOrIterations)) {
+                return promiseOrIterations.then(value => {
+                    if (typeof value === 'number') {
+                        return {
+                            iterationsAsync: value,
+                            iterationsSync: 0,
+                        };
+                    }
+                    if (value !== null && typeof value === 'object') {
+                        return value;
+                    }
+                    return {
+                        iterationsAsync: 1,
+                        iterationsSync: 0,
+                    };
+                }, err => {
+                    return onError(err, args, index);
+                });
+            }
+            const value = promiseOrIterations;
+            if (typeof value === 'number') {
+                return {
+                    iterationsAsync: 0,
+                    iterationsSync: value,
+                };
+            }
+            if (value !== null && typeof value === 'object') {
+                return value;
+            }
+            return {
+                iterationsAsync: 0,
+                iterationsSync: 1,
+            };
+        }
+        catch (err) {
+            return onError(err, args, index);
+        }
+    };
+}
+
+export { testVariantsCreateTestRun };

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

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function testVariantsIterable({ argsTemplates, }) {
+    return {
+        [Symbol.iterator]() {
+            const keys = Object.keys(argsTemplates);
+            const templates = Object.values(argsTemplates);
+            const keysCount = keys.length;
+            const args = {};
+            function calcVariants(keyIndex) {
+                let template = templates[keyIndex];
+                if (typeof template === 'function') {
+                    template = template(args);
+                }
+                return template;
+            }
+            const indexes = [];
+            const variants = [];
+            for (let nArg = 0; nArg < keysCount; nArg++) {
+                indexes[nArg] = -1;
+                variants[nArg] = [];
+            }
+            variants[0] = calcVariants(0);
+            function nextVariant() {
+                for (let keyIndex = keysCount - 1; keyIndex >= 0; keyIndex--) {
+                    const valueIndex = indexes[keyIndex] + 1;
+                    if (valueIndex < variants[keyIndex].length) {
+                        const key = keys[keyIndex];
+                        const value = variants[keyIndex][valueIndex];
+                        indexes[keyIndex] = valueIndex;
+                        args[key] = value;
+                        for (keyIndex++; keyIndex < keysCount; keyIndex++) {
+                            const keyVariants = calcVariants(keyIndex);
+                            if (keyVariants.length === 0) {
+                                break;
+                            }
+                            indexes[keyIndex] = 0;
+                            variants[keyIndex] = keyVariants;
+                            const key = keys[keyIndex];
+                            const value = keyVariants[0];
+                            args[key] = value;
+                        }
+                        if (keyIndex >= keysCount) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            return {
+                next() {
+                    if (nextVariant()) {
+                        return {
+                            done: false,
+                            value: Object.assign({}, args),
+                        };
+                    }
+                    return { done: true, value: null };
+                },
+            };
+        },
+    };
+}
+
+exports.testVariantsIterable = testVariantsIterable;

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

@@ -0,0 +1,12 @@
+import { Obj } from "./types";
+export declare type TestVariantsTemplate<Args extends Obj, Value> = Value[] | ((args: Args) => Value[]);
+export declare type TestVariantsTemplates<Args extends Obj> = {
+    [key in keyof Args]: TestVariantsTemplate<Args, Args[key]>;
+};
+export declare type TestVariantsTemplatesExt<Args extends Obj, ArgsExtra extends Obj> = TestVariantsTemplates<{
+    [key in (keyof ArgsExtra | keyof Args)]: key extends keyof Args ? Args[key] : key extends keyof ArgsExtra ? ArgsExtra[key] : never;
+}>;
+export declare type TestVariantsIterableOptions<Args extends Obj, ArgsExtra extends Obj> = {
+    argsTemplates: TestVariantsTemplatesExt<Args, ArgsExtra>;
+};
+export declare function testVariantsIterable<Args extends Obj, ArgsExtra extends Obj>({ argsTemplates, }: TestVariantsIterableOptions<Args, ArgsExtra>): Iterable<Args>;

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

@@ -0,0 +1,63 @@
+function testVariantsIterable({ argsTemplates, }) {
+    return {
+        [Symbol.iterator]() {
+            const keys = Object.keys(argsTemplates);
+            const templates = Object.values(argsTemplates);
+            const keysCount = keys.length;
+            const args = {};
+            function calcVariants(keyIndex) {
+                let template = templates[keyIndex];
+                if (typeof template === 'function') {
+                    template = template(args);
+                }
+                return template;
+            }
+            const indexes = [];
+            const variants = [];
+            for (let nArg = 0; nArg < keysCount; nArg++) {
+                indexes[nArg] = -1;
+                variants[nArg] = [];
+            }
+            variants[0] = calcVariants(0);
+            function nextVariant() {
+                for (let keyIndex = keysCount - 1; keyIndex >= 0; keyIndex--) {
+                    const valueIndex = indexes[keyIndex] + 1;
+                    if (valueIndex < variants[keyIndex].length) {
+                        const key = keys[keyIndex];
+                        const value = variants[keyIndex][valueIndex];
+                        indexes[keyIndex] = valueIndex;
+                        args[key] = value;
+                        for (keyIndex++; keyIndex < keysCount; keyIndex++) {
+                            const keyVariants = calcVariants(keyIndex);
+                            if (keyVariants.length === 0) {
+                                break;
+                            }
+                            indexes[keyIndex] = 0;
+                            variants[keyIndex] = keyVariants;
+                            const key = keys[keyIndex];
+                            const value = keyVariants[0];
+                            args[key] = value;
+                        }
+                        if (keyIndex >= keysCount) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            return {
+                next() {
+                    if (nextVariant()) {
+                        return {
+                            done: false,
+                            value: Object.assign({}, args),
+                        };
+                    }
+                    return { done: true, value: null };
+                },
+            };
+        },
+    };
+}
+
+export { testVariantsIterable };