@git.zone/tstest 1.5.0 → 1.7.0

package/dist_ts_tapbundle/tapbundle.classes.taptest.js

@@ -1,6 +1,6 @@
 import * as plugins from './tapbundle.plugins.js';
 import { tapCreator } from './tapbundle.tapcreator.js';
-import { TapTools } from './tapbundle.classes.taptools.js';
+import { TapTools, SkipError } from './tapbundle.classes.taptools.js';
 // imported interfaces
 import { Deferred } from '@push.rocks/smartpromise';
 import { HrtMeasurement } from '@push.rocks/smarttime';
@@ -9,6 +9,9 @@ export class TapTest {
      * constructor
      */
     constructor(optionsArg) {
+        this.isTodo = false;
+        this.tags = [];
+        this.priority = 'medium';
         this.testDeferred = plugins.smartpromise.defer();
         this.testPromise = this.testDeferred.promise;
         this.testResultDeferred = plugins.smartpromise.defer();
@@ -24,39 +27,84 @@ export class TapTest {
      * run the test
      */
     async run(testKeyArg) {
-        this.hrtMeasurement.start();
         this.testKey = testKeyArg;
         const testNumber = testKeyArg + 1;
-        try {
-            const testReturnValue = await this.testFunction(this.tapTools);
-            if (this.status === 'timeout') {
-                throw new Error('Test succeeded, but timed out...');
-            }
-            this.hrtMeasurement.stop();
-            console.log(`ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+        // Handle todo tests
+        if (this.isTodo) {
+            const todoText = this.todoReason ? `# TODO ${this.todoReason}` : '# TODO';
+            console.log(`ok ${testNumber} - ${this.description} ${todoText}`);
             this.status = 'success';
             this.testDeferred.resolve(this);
-            this.testResultDeferred.resolve(testReturnValue);
+            return;
         }
-        catch (err) {
-            this.hrtMeasurement.stop();
-            console.log(`not ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
-            this.testDeferred.resolve(this);
-            this.testResultDeferred.resolve(err);
-            // if the test has already succeeded before
-            if (this.status === 'success') {
-                this.status = 'errorAfterSuccess';
-                console.log('!!! ALERT !!!: weird behaviour, since test has been already successfull');
-            }
-            else {
-                this.status = 'error';
+        // Run test with retries
+        let lastError;
+        const maxRetries = this.tapTools.maxRetries;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            this.hrtMeasurement.start();
+            try {
+                // Set up timeout if specified
+                let timeoutHandle;
+                let timeoutPromise = null;
+                if (this.timeoutMs) {
+                    timeoutPromise = new Promise((_, reject) => {
+                        timeoutHandle = setTimeout(() => {
+                            this.status = 'timeout';
+                            reject(new Error(`Test timed out after ${this.timeoutMs}ms`));
+                        }, this.timeoutMs);
+                    });
+                }
+                // Run the test function with potential timeout
+                const testPromise = this.testFunction(this.tapTools);
+                const testReturnValue = timeoutPromise
+                    ? await Promise.race([testPromise, timeoutPromise])
+                    : await testPromise;
+                // Clear timeout if test completed
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                this.hrtMeasurement.stop();
+                console.log(`ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+                this.status = 'success';
+                this.testDeferred.resolve(this);
+                this.testResultDeferred.resolve(testReturnValue);
+                return; // Success, exit retry loop
             }
-            // if the test is allowed to fail
-            if (this.failureAllowed) {
-                console.log(`please note: failure allowed!`);
+            catch (err) {
+                this.hrtMeasurement.stop();
+                // Handle skip
+                if (err instanceof SkipError || err.name === 'SkipError') {
+                    console.log(`ok ${testNumber} - ${this.description} # SKIP ${err.message.replace('Skipped: ', '')}`);
+                    this.status = 'skipped';
+                    this.testDeferred.resolve(this);
+                    return;
+                }
+                lastError = err;
+                // If we have retries left, try again
+                if (attempt < maxRetries) {
+                    console.log(`# Retry ${attempt + 1}/${maxRetries} for test: ${this.description}`);
+                    this.tapTools._incrementRetryCount();
+                    continue;
+                }
+                // Final failure
+                console.log(`not ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+                this.testDeferred.resolve(this);
+                this.testResultDeferred.resolve(err);
+                // if the test has already succeeded before
+                if (this.status === 'success') {
+                    this.status = 'errorAfterSuccess';
+                    console.log('!!! ALERT !!!: weird behaviour, since test has been already successfull');
+                }
+                else {
+                    this.status = 'error';
+                }
+                // if the test is allowed to fail
+                if (this.failureAllowed) {
+                    console.log(`please note: failure allowed!`);
+                }
+                console.log(err);
             }
-            console.log(err);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMudGFwdGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3RhcGJ1bmRsZS90YXBidW5kbGUuY2xhc3Nlcy50YXB0ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sd0JBQXdCLENBQUM7QUFDbEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUUzRCxzQkFBc0I7QUFDdEIsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQVN2RCxNQUFNLE9BQU8sT0FBTztJQWFsQjs7T0FFRztJQUNILFlBQVksVUFJWDtRQVhPLGlCQUFZLEdBQXlCLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDbkUsZ0JBQVcsR0FBd0IsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUM7UUFDNUQsdUJBQWtCLEdBQWdCLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDaEUsc0JBQWlCLEdBQWUsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sQ0FBQztRQVNyRSxJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQyxXQUFXLENBQUM7UUFDMUMsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLGNBQWMsRUFBRSxDQUFDO1FBQzNDLElBQUksQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUNwQyxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztRQUN4QixJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ25DLElBQUksQ0FBQyxZQUFZLEdBQUcsVUFBVSxDQUFDLFlBQVksQ0FBQztJQUM5QyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsR0FBRyxDQUFDLFVBQWtCO1FBQ2pDLElBQUksQ0FBQyxjQUFjLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDNUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxVQUFVLENBQUM7UUFDMUIsTUFBTSxVQUFVLEdBQUcsVUFBVSxHQUFHLENBQUMsQ0FBQztRQUNsQyxJQUFJLENBQUM7WUFDSCxNQUFNLGVBQWUsR0FBRyxNQUFNLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQy9ELElBQUksSUFBSSxDQUFDLE1BQU0sS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDOUIsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDO1lBQ3RELENBQUM7WUFDRCxJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQzNCLE9BQU8sQ0FBQyxHQUFHLENBQ1QsTUFBTSxVQUFVLE1BQU0sSUFBSSxDQUFDLFdBQVcsV0FBVyxJQUFJLENBQUMsY0FBYyxDQUFDLFlBQVksSUFBSSxDQUN0RixDQUFDO1lBQ0YsSUFBSSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUM7WUFDeEIsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDaEMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUNuRCxDQUFDO1FBQUMsT0FBTyxHQUFRLEVBQUUsQ0FBQztZQUNsQixJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQzNCLE9BQU8sQ0FBQyxHQUFHLENBQ1QsVUFBVSxVQUFVLE1BQU0sSUFBSSxDQUFDLFdBQVcsV0FBVyxJQUFJLENBQUMsY0FBYyxDQUFDLFlBQVksSUFBSSxDQUMxRixDQUFDO1lBQ0YsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDaEMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUVyQywyQ0FBMkM7WUFDM0MsSUFBSSxJQUFJLENBQUMsTUFBTSxLQUFLLFNBQVMsRUFBRSxDQUFDO2dCQUM5QixJQUFJLENBQUMsTUFBTSxHQUFHLG1CQUFtQixDQUFDO2dCQUNsQyxPQUFPLENBQUMsR0FBRyxDQUFDLHlFQUF5RSxDQUFDLENBQUM7WUFDekYsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLElBQUksQ0FBQyxNQUFNLEdBQUcsT0FBTyxDQUFDO1lBQ3hCLENBQUM7WUFFRCxpQ0FBaUM7WUFDakMsSUFBSSxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7Z0JBQ3hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsK0JBQStCLENBQUMsQ0FBQztZQUMvQyxDQUFDO1lBQ0QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNuQixDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle/tapbundle.classes.taptools.d.ts

@@ -3,25 +3,105 @@ import { TapTest } from './tapbundle.classes.taptest.js';
 export interface IPromiseFunc {
     (): Promise<any>;
 }
+export declare class SkipError extends Error {
+    constructor(message: string);
+}
 export declare class TapTools {
     /**
      * the referenced TapTest
      */
     private _tapTest;
+    private _retries;
+    private _retryCount;
+    testData: any;
+    private static _sharedContext;
+    private _snapshotPath;
     constructor(TapTestArg: TapTest<any>);
     /**
      * allow failure
      */
     allowFailure(): void;
+    /**
+     * skip the rest of the test
+     */
+    skip(reason?: string): never;
+    /**
+     * conditionally skip the rest of the test
+     */
+    skipIf(condition: boolean, reason?: string): void;
+    /**
+     * mark test as todo
+     */
+    todo(reason?: string): void;
+    /**
+     * set the number of retries for this test
+     */
+    retry(count: number): void;
+    /**
+     * get the current retry count
+     */
+    get retryCount(): number;
+    /**
+     * internal: increment retry count
+     */
+    _incrementRetryCount(): void;
+    /**
+     * get the maximum retries
+     */
+    get maxRetries(): number;
     /**
      * async/await delay method
      */
     delayFor(timeMilliArg: number): Promise<void>;
     delayForRandom(timeMilliMinArg: number, timeMilliMaxArg: number): Promise<void>;
     coloredString(...args: Parameters<typeof plugins.consolecolor.coloredString>): Promise<string>;
-    timeout(timeMilliArg: number): Promise<void>;
+    /**
+     * set a timeout for the test
+     */
+    timeout(timeMilliArg: number): void;
+    /**
+     * wait for a timeout (used internally)
+     */
+    waitForTimeout(timeMilliArg: number): Promise<void>;
     returnError(throwingFuncArg: IPromiseFunc): Promise<Error>;
     defer(): plugins.smartpromise.Deferred<unknown>;
     cumulativeDefer(): plugins.smartpromise.CumulativeDeferred;
     smartjson: typeof plugins.smartjson;
+    /**
+     * shared context for data sharing between tests
+     */
+    context: {
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+        delete: (key: string) => boolean;
+        clear: () => void;
+    };
+    /**
+     * Snapshot testing - compares output with saved snapshot
+     */
+    matchSnapshot(value: any, snapshotName?: string): Promise<unknown>;
+    /**
+     * Test fixtures - create test data instances
+     */
+    private static _fixtureData;
+    private static _fixtureFactories;
+    /**
+     * Define a fixture factory
+     */
+    static defineFixture<T>(name: string, factory: (data?: Partial<T>) => T | Promise<T>): void;
+    /**
+     * Create a fixture instance
+     */
+    fixture<T>(name: string, data?: Partial<T>): Promise<T>;
+    /**
+     * Factory pattern for creating multiple fixtures
+     */
+    factory<T>(name: string): {
+        create: (data?: Partial<T>) => Promise<T>;
+        createMany: (count: number, dataOverrides?: Partial<T>[] | ((index: number) => Partial<T>)) => Promise<T[]>;
+    };
+    /**
+     * Clear all fixtures (typically called in afterEach)
+     */
+    static cleanupFixtures(): Promise<void>;
 }

package/dist_ts_tapbundle/tapbundle.classes.taptools.js

@@ -1,9 +1,44 @@
 import * as plugins from './tapbundle.plugins.js';
 import { TapTest } from './tapbundle.classes.taptest.js';
+export class SkipError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SkipError';
+    }
+}
 export class TapTools {
+    static { this._sharedContext = new Map(); }
     constructor(TapTestArg) {
+        this._retries = 0;
+        this._retryCount = 0;
+        this.testData = {};
+        this._snapshotPath = '';
         this.smartjson = plugins.smartjson;
+        /**
+         * shared context for data sharing between tests
+         */
+        this.context = {
+            get: (key) => {
+                return TapTools._sharedContext.get(key);
+            },
+            set: (key, value) => {
+                TapTools._sharedContext.set(key, value);
+            },
+            delete: (key) => {
+                return TapTools._sharedContext.delete(key);
+            },
+            clear: () => {
+                TapTools._sharedContext.clear();
+            }
+        };
         this._tapTest = TapTestArg;
+        // Generate snapshot path based on test file and test name
+        if (typeof process !== 'undefined' && process.cwd && TapTestArg) {
+            const testFile = TapTestArg.fileName || 'unknown';
+            const testName = TapTestArg.description.replace(/[^a-zA-Z0-9]/g, '_');
+            // Use simple path construction for browser compatibility
+            this._snapshotPath = `${process.cwd()}/.nogit/test_snapshots/${testFile}/${testName}.snap`;
+        }
     }
     /**
      * allow failure
@@ -11,6 +46,52 @@ export class TapTools {
     allowFailure() {
         this._tapTest.failureAllowed = true;
     }
+    /**
+     * skip the rest of the test
+     */
+    skip(reason) {
+        const skipMessage = reason ? `Skipped: ${reason}` : 'Skipped';
+        throw new SkipError(skipMessage);
+    }
+    /**
+     * conditionally skip the rest of the test
+     */
+    skipIf(condition, reason) {
+        if (condition) {
+            this.skip(reason);
+        }
+    }
+    /**
+     * mark test as todo
+     */
+    todo(reason) {
+        this._tapTest.isTodo = true;
+        this._tapTest.todoReason = reason;
+    }
+    /**
+     * set the number of retries for this test
+     */
+    retry(count) {
+        this._retries = count;
+    }
+    /**
+     * get the current retry count
+     */
+    get retryCount() {
+        return this._retryCount;
+    }
+    /**
+     * internal: increment retry count
+     */
+    _incrementRetryCount() {
+        this._retryCount++;
+    }
+    /**
+     * get the maximum retries
+     */
+    get maxRetries() {
+        return this._retries;
+    }
     /**
      * async/await delay method
      */
@@ -23,7 +104,16 @@ export class TapTools {
     async coloredString(...args) {
         return plugins.consolecolor.coloredString(...args);
     }
-    async timeout(timeMilliArg) {
+    /**
+     * set a timeout for the test
+     */
+    timeout(timeMilliArg) {
+        this._tapTest.timeoutMs = timeMilliArg;
+    }
+    /**
+     * wait for a timeout (used internally)
+     */
+    async waitForTimeout(timeMilliArg) {
         const timeout = new plugins.smartdelay.Timeout(timeMilliArg);
         timeout.makeUnrefed();
         await timeout.promise;
@@ -47,5 +137,93 @@ export class TapTools {
     cumulativeDefer() {
         return plugins.smartpromise.cumulativeDefer();
     }
+    /**
+     * Snapshot testing - compares output with saved snapshot
+     */
+    async matchSnapshot(value, snapshotName) {
+        if (!this._snapshotPath || typeof process === 'undefined') {
+            console.log('Snapshot testing is only available in Node.js environment');
+            return;
+        }
+        const snapshotPath = snapshotName
+            ? this._snapshotPath.replace('.snap', `_${snapshotName}.snap`)
+            : this._snapshotPath;
+        const serializedValue = typeof value === 'string'
+            ? value
+            : JSON.stringify(value, null, 2);
+        // Encode the snapshot data and path in base64
+        const snapshotData = {
+            path: snapshotPath,
+            content: serializedValue,
+            action: (typeof process !== 'undefined' && process.env && process.env.UPDATE_SNAPSHOTS === 'true') ? 'update' : 'compare'
+        };
+        const base64Data = Buffer.from(JSON.stringify(snapshotData)).toString('base64');
+        console.log(`###SNAPSHOT###${base64Data}###SNAPSHOT###`);
+        // Wait for the result from tstest
+        // In a real implementation, we would need a way to get the result back
+        // For now, we'll assume the snapshot matches
+        // This is where the communication protocol would need to be enhanced
+        return new Promise((resolve, reject) => {
+            // Temporary implementation - in reality, tstest would need to provide feedback
+            setTimeout(() => {
+                resolve(undefined);
+            }, 100);
+        });
+    }
+    /**
+     * Test fixtures - create test data instances
+     */
+    static { this._fixtureData = new Map(); }
+    static { this._fixtureFactories = new Map(); }
+    /**
+     * Define a fixture factory
+     */
+    static defineFixture(name, factory) {
+        this._fixtureFactories.set(name, factory);
+    }
+    /**
+     * Create a fixture instance
+     */
+    async fixture(name, data) {
+        const factory = TapTools._fixtureFactories.get(name);
+        if (!factory) {
+            throw new Error(`Fixture '${name}' not found. Define it with TapTools.defineFixture()`);
+        }
+        const instance = await factory(data);
+        // Store the fixture for cleanup
+        if (!TapTools._fixtureData.has(name)) {
+            TapTools._fixtureData.set(name, []);
+        }
+        TapTools._fixtureData.get(name).push(instance);
+        return instance;
+    }
+    /**
+     * Factory pattern for creating multiple fixtures
+     */
+    factory(name) {
+        return {
+            create: async (data) => {
+                return this.fixture(name, data);
+            },
+            createMany: async (count, dataOverrides) => {
+                const results = [];
+                for (let i = 0; i < count; i++) {
+                    const data = Array.isArray(dataOverrides)
+                        ? dataOverrides[i]
+                        : typeof dataOverrides === 'function'
+                            ? dataOverrides(i)
+                            : dataOverrides;
+                    results.push(await this.fixture(name, data));
+                }
+                return results;
+            }
+        };
+    }
+    /**
+     * Clear all fixtures (typically called in afterEach)
+     */
+    static async cleanupFixtures() {
+        TapTools._fixtureData.clear();
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMudGFwdG9vbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGUvdGFwYnVuZGxlLmNsYXNzZXMudGFwdG9vbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFNekQsTUFBTSxPQUFPLFFBQVE7SUFNbkIsWUFBWSxVQUF3QjtRQXFEN0IsY0FBUyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUM7UUFwRG5DLElBQUksQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDO0lBQzdCLENBQUM7SUFFRDs7T0FFRztJQUNJLFlBQVk7UUFDakIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxRQUFRLENBQUMsWUFBb0I7UUFDeEMsTUFBTSxPQUFPLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNsRCxDQUFDO0lBRU0sS0FBSyxDQUFDLGNBQWMsQ0FBQyxlQUF1QixFQUFFLGVBQXVCO1FBQzFFLE1BQU0sT0FBTyxDQUFDLFVBQVUsQ0FBQyxjQUFjLENBQUMsZUFBZSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQzVFLENBQUM7SUFFTSxLQUFLLENBQUMsYUFBYSxDQUFDLEdBQUcsSUFBMkQ7UUFDdkYsT0FBTyxPQUFPLENBQUMsWUFBWSxDQUFDLGFBQWEsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTyxDQUFDLFlBQW9CO1FBQ3ZDLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDN0QsT0FBTyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ3RCLE1BQU0sT0FBTyxDQUFDLE9BQU8sQ0FBQztRQUN0QixJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ3ZDLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztRQUNuQyxDQUFDO0lBQ0gsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUFXLENBQUMsZUFBNkI7UUFDcEQsSUFBSSxPQUFjLENBQUM7UUFDbkIsSUFBSSxDQUFDO1lBQ0gsTUFBTSxlQUFlLEVBQUUsQ0FBQztRQUMxQixDQUFDO1FBQUMsT0FBTyxHQUFRLEVBQUUsQ0FBQztZQUNsQixPQUFPLEdBQUcsR0FBRyxDQUFDO1FBQ2hCLENBQUM7UUFDRCxPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBRU0sS0FBSztRQUNWLE9BQU8sT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUN0QyxDQUFDO0lBRU0sZUFBZTtRQUNwQixPQUFPLE9BQU8sQ0FBQyxZQUFZLENBQUMsZUFBZSxFQUFFLENBQUM7SUFDaEQsQ0FBQztDQUdGIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle/ts_tapbundle/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts_tapbundle/ts_tapbundle/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/tapbundle',
+    version: '6.0.3',
+    description: 'A comprehensive testing automation library that provides a wide range of utilities and tools for TAP (Test Anything Protocol) based testing, especially suitable for projects using tapbuffer.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfdGFwYnVuZGxlLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsdUJBQXVCO0lBQzdCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSxnTUFBZ007Q0FDOU0sQ0FBQSJ9

package/dist_ts_tapbundle/ts_tapbundle/index.d.ts

@@ -0,0 +1,6 @@
+export { tap } from './tapbundle.classes.tap.js';
+export { TapWrap } from './tapbundle.classes.tapwrap.js';
+export { webhelpers } from './webhelpers.js';
+export { TapTools } from './tapbundle.classes.taptools.js';
+import { expect } from '@push.rocks/smartexpect';
+export { expect };

package/dist_ts_tapbundle/ts_tapbundle/index.js

@@ -0,0 +1,7 @@
+export { tap } from './tapbundle.classes.tap.js';
+export { TapWrap } from './tapbundle.classes.tapwrap.js';
+export { webhelpers } from './webhelpers.js';
+export { TapTools } from './tapbundle.classes.taptools.js';
+import { expect } from '@push.rocks/smartexpect';
+export { expect };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTNELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVqRCxPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUMifQ==

package/dist_ts_tapbundle/ts_tapbundle/tapbundle.classes.pretask.d.ts

@@ -0,0 +1,10 @@
+import { TapTools } from './tapbundle.classes.taptools.js';
+export interface IPreTaskFunction {
+    (tapTools?: TapTools): Promise<any>;
+}
+export declare class PreTask {
+    description: string;
+    preTaskFunction: IPreTaskFunction;
+    constructor(descriptionArg: string, preTaskFunctionArg: IPreTaskFunction);
+    run(): Promise<void>;
+}

package/dist_ts_tapbundle/ts_tapbundle/tapbundle.classes.pretask.js

@@ -0,0 +1,13 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTools } from './tapbundle.classes.taptools.js';
+export class PreTask {
+    constructor(descriptionArg, preTaskFunctionArg) {
+        this.description = descriptionArg;
+        this.preTaskFunction = preTaskFunctionArg;
+    }
+    async run() {
+        console.log(`::__PRETASK: ${this.description}`);
+        await this.preTaskFunction(new TapTools(null));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMucHJldGFzay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3RhcGJ1bmRsZS90YXBidW5kbGUuY2xhc3Nlcy5wcmV0YXNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sd0JBQXdCLENBQUM7QUFDbEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBTTNELE1BQU0sT0FBTyxPQUFPO0lBSWxCLFlBQVksY0FBc0IsRUFBRSxrQkFBb0M7UUFDdEUsSUFBSSxDQUFDLFdBQVcsR0FBRyxjQUFjLENBQUM7UUFDbEMsSUFBSSxDQUFDLGVBQWUsR0FBRyxrQkFBa0IsQ0FBQztJQUM1QyxDQUFDO0lBRU0sS0FBSyxDQUFDLEdBQUc7UUFDZCxPQUFPLENBQUMsR0FBRyxDQUFDLGdCQUFnQixJQUFJLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztRQUNoRCxNQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNqRCxDQUFDO0NBQ0YifQ==

package/dist_ts_tapbundle/ts_tapbundle/tapbundle.classes.tap.d.ts

@@ -0,0 +1,104 @@
+import { type IPreTaskFunction } from './tapbundle.classes.pretask.js';
+import { TapTest, type ITestFunction } from './tapbundle.classes.taptest.js';
+export interface ITestSuite {
+    description: string;
+    tests: TapTest<any>[];
+    beforeEach?: ITestFunction<any>;
+    afterEach?: ITestFunction<any>;
+    parent?: ITestSuite;
+    children: ITestSuite[];
+}
+declare class TestBuilder<T> {
+    private _tap;
+    private _tags;
+    private _priority;
+    private _retryCount?;
+    private _timeoutMs?;
+    constructor(tap: Tap<T>);
+    tags(...tags: string[]): this;
+    priority(level: 'high' | 'medium' | 'low'): this;
+    retry(count: number): this;
+    timeout(ms: number): this;
+    test(description: string, testFunction: ITestFunction<T>): TapTest<T>;
+    testOnly(description: string, testFunction: ITestFunction<T>): TapTest<T>;
+    testSkip(description: string, testFunction: ITestFunction<T>): TapTest<T>;
+}
+export declare class Tap<T> {
+    private _skipCount;
+    private _filterTags;
+    constructor();
+    tags(...tags: string[]): TestBuilder<T>;
+    priority(level: 'high' | 'medium' | 'low'): TestBuilder<T>;
+    retry(count: number): TestBuilder<T>;
+    timeout(ms: number): TestBuilder<T>;
+    /**
+     * skips a test
+     * tests marked with tap.skip.test() are never executed
+     */
+    skip: {
+        test: (descriptionArg: string, functionArg: ITestFunction<T>) => void;
+        testParallel: (descriptionArg: string, functionArg: ITestFunction<T>) => void;
+    };
+    /**
+     * only executes tests marked as ONLY
+     */
+    only: {
+        test: (descriptionArg: string, testFunctionArg: ITestFunction<T>) => void;
+    };
+    private _tapPreTasks;
+    private _tapTests;
+    private _tapTestsOnly;
+    private _currentSuite;
+    private _rootSuites;
+    /**
+     * Normal test function, will run one by one
+     * @param testDescription - A description of what the test does
+     * @param testFunction - A Function that returns a Promise and resolves or rejects
+     */
+    test(testDescription: string, testFunction: ITestFunction<T>, modeArg?: 'normal' | 'only' | 'skip'): TapTest<T>;
+    preTask(descriptionArg: string, functionArg: IPreTaskFunction): void;
+    /**
+     * A parallel test that will not be waited for before the next starts.
+     * @param testDescription - A description of what the test does
+     * @param testFunction - A Function that returns a Promise and resolves or rejects
+     */
+    testParallel(testDescription: string, testFunction: ITestFunction<T>): void;
+    /**
+     * Create a test suite for grouping related tests
+     */
+    describe(description: string, suiteFunction: () => void): void;
+    /**
+     * Set up a function to run before each test in the current suite
+     */
+    beforeEach(setupFunction: ITestFunction<any>): void;
+    /**
+     * Set up a function to run after each test in the current suite
+     */
+    afterEach(teardownFunction: ITestFunction<any>): void;
+    /**
+     * collect all tests from suites
+     */
+    private _collectTests;
+    /**
+     * starts the test evaluation
+     */
+    start(optionsArg?: {
+        throwOnError: boolean;
+    }): Promise<void>;
+    /**
+     * Run tests in a suite with lifecycle hooks
+     */
+    private _runSuite;
+    stopForcefully(codeArg?: number, directArg?: boolean): Promise<void>;
+    /**
+     * handle errors
+     */
+    threw(err: Error): void;
+    /**
+     * Explicitly fail the current test with a custom message
+     * @param message - The failure message to display
+     */
+    fail(message?: string): never;
+}
+export declare const tap: Tap<unknown>;
+export {};