@git.zone/tstest 1.5.0 → 1.8.0

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

@@ -1,6 +1,36 @@
 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
@@ -18,6 +48,8 @@ export declare class Tap<T> {
     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
@@ -31,12 +63,32 @@ export declare class Tap<T> {
      * @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
@@ -48,4 +100,5 @@ export declare class Tap<T> {
      */
     fail(message?: string): never;
 }
-export declare let tap: Tap<unknown>;
+export declare const tap: Tap<unknown>;
+export {};

package/dist_ts_tapbundle/tapbundle.classes.tap.js

@@ -1,8 +1,78 @@
 import * as plugins from './tapbundle.plugins.js';
 import { PreTask } from './tapbundle.classes.pretask.js';
 import { TapTest } from './tapbundle.classes.taptest.js';
+class TestBuilder {
+    constructor(tap) {
+        this._tags = [];
+        this._priority = 'medium';
+        this._tap = tap;
+    }
+    tags(...tags) {
+        this._tags = tags;
+        return this;
+    }
+    priority(level) {
+        this._priority = level;
+        return this;
+    }
+    retry(count) {
+        this._retryCount = count;
+        return this;
+    }
+    timeout(ms) {
+        this._timeoutMs = ms;
+        return this;
+    }
+    test(description, testFunction) {
+        const test = this._tap.test(description, testFunction, 'normal');
+        // Apply settings to the test
+        if (this._tags.length > 0) {
+            test.tags = this._tags;
+        }
+        test.priority = this._priority;
+        if (this._retryCount !== undefined) {
+            test.tapTools.retry(this._retryCount);
+        }
+        if (this._timeoutMs !== undefined) {
+            test.timeoutMs = this._timeoutMs;
+        }
+        return test;
+    }
+    testOnly(description, testFunction) {
+        const test = this._tap.test(description, testFunction, 'only');
+        // Apply settings to the test
+        if (this._tags.length > 0) {
+            test.tags = this._tags;
+        }
+        test.priority = this._priority;
+        if (this._retryCount !== undefined) {
+            test.tapTools.retry(this._retryCount);
+        }
+        if (this._timeoutMs !== undefined) {
+            test.timeoutMs = this._timeoutMs;
+        }
+        return test;
+    }
+    testSkip(description, testFunction) {
+        const test = this._tap.test(description, testFunction, 'skip');
+        // Apply settings to the test
+        if (this._tags.length > 0) {
+            test.tags = this._tags;
+        }
+        test.priority = this._priority;
+        if (this._retryCount !== undefined) {
+            test.tapTools.retry(this._retryCount);
+        }
+        if (this._timeoutMs !== undefined) {
+            test.timeoutMs = this._timeoutMs;
+        }
+        return test;
+    }
+}
 export class Tap {
     constructor() {
+        this._skipCount = 0;
+        this._filterTags = [];
         /**
          * skips a test
          * tests marked with tap.skip.test() are never executed
@@ -10,9 +80,11 @@ export class Tap {
         this.skip = {
             test: (descriptionArg, functionArg) => {
                 console.log(`skipped test: ${descriptionArg}`);
+                this._skipCount++;
             },
             testParallel: (descriptionArg, functionArg) => {
                 console.log(`skipped test: ${descriptionArg}`);
+                this._skipCount++;
             },
         };
         /**
@@ -26,6 +98,29 @@ export class Tap {
         this._tapPreTasks = [];
         this._tapTests = [];
         this._tapTestsOnly = [];
+        this._currentSuite = null;
+        this._rootSuites = [];
+        // Get filter tags from environment
+        if (typeof process !== 'undefined' && process.env && process.env.TSTEST_FILTER_TAGS) {
+            this._filterTags = process.env.TSTEST_FILTER_TAGS.split(',');
+        }
+    }
+    // Fluent test builder
+    tags(...tags) {
+        const builder = new TestBuilder(this);
+        return builder.tags(...tags);
+    }
+    priority(level) {
+        const builder = new TestBuilder(this);
+        return builder.priority(level);
+    }
+    retry(count) {
+        const builder = new TestBuilder(this);
+        return builder.retry(count);
+    }
+    timeout(ms) {
+        const builder = new TestBuilder(this);
+        return builder.timeout(ms);
     }
     /**
      * Normal test function, will run one by one
@@ -38,11 +133,19 @@ export class Tap {
             testFunction,
             parallel: false,
         });
-        if (modeArg === 'normal') {
-            this._tapTests.push(localTest);
+        // No options applied here - use the fluent builder syntax instead
+        // If we're in a suite, add test to the suite
+        if (this._currentSuite) {
+            this._currentSuite.tests.push(localTest);
         }
-        else if (modeArg === 'only') {
-            this._tapTestsOnly.push(localTest);
+        else {
+            // Otherwise add to global test list
+            if (modeArg === 'normal') {
+                this._tapTests.push(localTest);
+            }
+            else if (modeArg === 'only') {
+                this._tapTestsOnly.push(localTest);
+            }
         }
         return localTest;
     }
@@ -55,11 +158,76 @@ export class Tap {
      * @param testFunction - A Function that returns a Promise and resolves or rejects
      */
     testParallel(testDescription, testFunction) {
-        this._tapTests.push(new TapTest({
+        const localTest = new TapTest({
             description: testDescription,
             testFunction,
             parallel: true,
-        }));
+        });
+        if (this._currentSuite) {
+            this._currentSuite.tests.push(localTest);
+        }
+        else {
+            this._tapTests.push(localTest);
+        }
+    }
+    /**
+     * Create a test suite for grouping related tests
+     */
+    describe(description, suiteFunction) {
+        const suite = {
+            description,
+            tests: [],
+            children: [],
+            parent: this._currentSuite,
+        };
+        // Add to parent or root
+        if (this._currentSuite) {
+            this._currentSuite.children.push(suite);
+        }
+        else {
+            this._rootSuites.push(suite);
+        }
+        // Execute suite function in context
+        const previousSuite = this._currentSuite;
+        this._currentSuite = suite;
+        try {
+            suiteFunction();
+        }
+        finally {
+            this._currentSuite = previousSuite;
+        }
+    }
+    /**
+     * Set up a function to run before each test in the current suite
+     */
+    beforeEach(setupFunction) {
+        if (this._currentSuite) {
+            this._currentSuite.beforeEach = setupFunction;
+        }
+        else {
+            throw new Error('beforeEach can only be used inside a describe block');
+        }
+    }
+    /**
+     * Set up a function to run after each test in the current suite
+     */
+    afterEach(teardownFunction) {
+        if (this._currentSuite) {
+            this._currentSuite.afterEach = teardownFunction;
+        }
+        else {
+            throw new Error('afterEach can only be used inside a describe block');
+        }
+    }
+    /**
+     * collect all tests from suites
+     */
+    _collectTests(suite, tests = []) {
+        tests.push(...suite.tests);
+        for (const childSuite of suite.children) {
+            this._collectTests(childSuite, tests);
+        }
+        return tests;
     }
     /**
      * starts the test evaluation
@@ -67,15 +235,25 @@ export class Tap {
     async start(optionsArg) {
         // lets set the tapbundle promise
         const smartenvInstance = new plugins.smartenv.Smartenv();
+        const globalPromise = plugins.smartpromise.defer();
         smartenvInstance.isBrowser
-            ? (globalThis.tapbundleDeferred = plugins.smartpromise.defer())
+            ? (globalThis.tapbundleDeferred = globalPromise)
             : null;
+        // Also set tapPromise for backwards compatibility
+        smartenvInstance.isBrowser
+            ? (globalThis.tapPromise = globalPromise.promise)
+            : null;
+        // Path helpers will be initialized by the Node.js environment if available
         // lets continue with running the tests
         const promiseArray = [];
+        // Collect all tests including those in suites
+        let allTests = [...this._tapTests];
+        for (const suite of this._rootSuites) {
+            this._collectTests(suite, allTests);
+        }
         // safeguard against empty test array
-        if (this._tapTests.length === 0) {
+        if (allTests.length === 0 && this._tapTestsOnly.length === 0) {
             console.log('no tests specified. Ending here!');
-            // TODO: throw proper error
             return;
         }
         // determine which tests to run
@@ -84,16 +262,49 @@ export class Tap {
             concerningTests = this._tapTestsOnly;
         }
         else {
-            concerningTests = this._tapTests;
+            concerningTests = allTests;
+        }
+        // Filter tests by tags if specified
+        if (this._filterTags.length > 0) {
+            concerningTests = concerningTests.filter(test => {
+                // Skip tests without tags when filtering is active
+                if (!test.tags || test.tags.length === 0) {
+                    return false;
+                }
+                // Check if test has any of the filter tags
+                return test.tags.some(tag => this._filterTags.includes(tag));
+            });
         }
         // lets run the pretasks
         for (const preTask of this._tapPreTasks) {
             await preTask.run();
         }
+        // Count actual tests that will be run
         console.log(`1..${concerningTests.length}`);
-        for (let testKey = 0; testKey < concerningTests.length; testKey++) {
-            const currentTest = concerningTests[testKey];
-            const testPromise = currentTest.run(testKey);
+        // Run tests from suites with lifecycle hooks
+        let testKey = 0;
+        // Run root suite tests with lifecycle hooks
+        if (this._rootSuites.length > 0) {
+            await this._runSuite(null, this._rootSuites, promiseArray, { testKey });
+            // Update testKey after running suite tests
+            for (const suite of this._rootSuites) {
+                const suiteTests = this._collectTests(suite);
+                testKey += suiteTests.length;
+            }
+        }
+        // Run non-suite tests (tests added directly without describe)
+        const nonSuiteTests = concerningTests.filter(test => {
+            // Check if test is not in any suite
+            for (const suite of this._rootSuites) {
+                const suiteTests = this._collectTests(suite);
+                if (suiteTests.includes(test)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        for (const currentTest of nonSuiteTests) {
+            const testPromise = currentTest.run(testKey++);
             if (currentTest.parallel) {
                 promiseArray.push(testPromise);
             }
@@ -107,7 +318,7 @@ export class Tap {
         const executionNotes = [];
         // collect failed tests
         for (const tapTest of concerningTests) {
-            if (tapTest.status !== 'success') {
+            if (tapTest.status !== 'success' && tapTest.status !== 'skipped') {
                 failReasons.push(`Test ${tapTest.testKey + 1} failed with status ${tapTest.status}:\n` +
                     `|| ${tapTest.description}\n` +
                     `|| for more information please take a look the logs above`);
@@ -118,22 +329,75 @@ export class Tap {
             console.log(failReason);
         }
         if (optionsArg && optionsArg.throwOnError && failReasons.length > 0) {
-            if (!smartenvInstance.isBrowser)
+            if (!smartenvInstance.isBrowser && typeof process !== 'undefined')
                 process.exit(1);
         }
         if (smartenvInstance.isBrowser) {
-            globalThis.tapbundleDeferred.resolve();
+            globalPromise.resolve();
+        }
+    }
+    /**
+     * Run tests in a suite with lifecycle hooks
+     */
+    async _runSuite(parentSuite, suites, promiseArray, context) {
+        for (const suite of suites) {
+            // Run beforeEach from parent suites
+            const beforeEachFunctions = [];
+            let currentSuite = suite;
+            while (currentSuite) {
+                if (currentSuite.beforeEach) {
+                    beforeEachFunctions.unshift(currentSuite.beforeEach);
+                }
+                currentSuite = currentSuite.parent || null;
+            }
+            // Run tests in this suite
+            for (const test of suite.tests) {
+                // Create wrapper test function that includes lifecycle hooks
+                const originalFunction = test.testFunction;
+                test.testFunction = async (tapTools) => {
+                    // Run all beforeEach hooks
+                    for (const beforeEach of beforeEachFunctions) {
+                        await beforeEach(tapTools);
+                    }
+                    // Run the actual test
+                    const result = await originalFunction(tapTools);
+                    // Run afterEach hooks in reverse order
+                    const afterEachFunctions = [];
+                    currentSuite = suite;
+                    while (currentSuite) {
+                        if (currentSuite.afterEach) {
+                            afterEachFunctions.push(currentSuite.afterEach);
+                        }
+                        currentSuite = currentSuite.parent || null;
+                    }
+                    for (const afterEach of afterEachFunctions) {
+                        await afterEach(tapTools);
+                    }
+                    return result;
+                };
+                const testPromise = test.run(context.testKey++);
+                if (test.parallel) {
+                    promiseArray.push(testPromise);
+                }
+                else {
+                    await testPromise;
+                }
+            }
+            // Recursively run child suites
+            await this._runSuite(suite, suite.children, promiseArray, context);
         }
     }
     async stopForcefully(codeArg = 0, directArg = false) {
         console.log(`tap stopping forcefully! Code: ${codeArg} / Direct: ${directArg}`);
-        if (directArg) {
-            process.exit(codeArg);
-        }
-        else {
-            setTimeout(() => {
+        if (typeof process !== 'undefined') {
+            if (directArg) {
                 process.exit(codeArg);
-            }, 10);
+            }
+            else {
+                setTimeout(() => {
+                    process.exit(codeArg);
+                }, 10);
+            }
         }
     }
     /**
@@ -150,5 +414,5 @@ export class Tap {
         throw new Error(message);
     }
 }
-export let tap = new Tap();
-//# sourceMappingURL=data:application/json;base64,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
+export const tap = new Tap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tapbundle.classes.tap.js","sourceRoot":"","sources":["../ts_tapbundle/tapbundle.classes.tap.ts"],"names":[],"mappings":"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"}

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

@@ -1,6 +1,6 @@
 import { TapTools } from './tapbundle.classes.taptools.js';
 import { HrtMeasurement } from '@push.rocks/smarttime';
-export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout';
+export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout' | 'skipped';
 export interface ITestFunction<T> {
     (tapTools?: TapTools): Promise<T>;
 }
@@ -13,6 +13,12 @@ export declare class TapTest<T = unknown> {
     tapTools: TapTools;
     testFunction: ITestFunction<T>;
     testKey: number;
+    timeoutMs?: number;
+    isTodo: boolean;
+    todoReason?: string;
+    tags: string[];
+    priority: 'high' | 'medium' | 'low';
+    fileName?: string;
     private testDeferred;
     testPromise: Promise<TapTest<T>>;
     private testResultDeferred;