@git.zone/tstest 1.11.5 → 2.2.1

package/dist_ts_tapbundle/tapbundle.classes.taptest.js

@@ -1,6 +1,8 @@
 import * as plugins from './tapbundle.plugins.js';
 import { tapCreator } from './tapbundle.tapcreator.js';
 import { TapTools, SkipError } from './tapbundle.classes.taptools.js';
+import { ProtocolEmitter } from '../dist_ts_tapbundle_protocol/index.js';
+import { setProtocolEmitter } from './tapbundle.expect.wrapper.js';
 // imported interfaces
 import { Deferred } from '@push.rocks/smartpromise';
 import { HrtMeasurement } from '@push.rocks/smarttime';
@@ -16,6 +18,7 @@ export class TapTest {
         this.testPromise = this.testDeferred.promise;
         this.testResultDeferred = plugins.smartpromise.defer();
         this.testResultPromise = this.testResultDeferred.promise;
+        this.protocolEmitter = new ProtocolEmitter();
         this.description = optionsArg.description;
         this.hrtMeasurement = new HrtMeasurement();
         this.parallel = optionsArg.parallel;
@@ -23,17 +26,80 @@ export class TapTest {
         this.tapTools = new TapTools(this);
         this.testFunction = optionsArg.testFunction;
     }
+    /**
+     * Emit an event
+     */
+    emitEvent(event) {
+        console.log(this.protocolEmitter.emitEvent(event));
+    }
     /**
      * run the test
      */
     async run(testKeyArg) {
         this.testKey = testKeyArg;
         const testNumber = testKeyArg + 1;
+        // Emit test:queued event
+        this.emitEvent({
+            eventType: 'test:queued',
+            timestamp: Date.now(),
+            data: {
+                testNumber,
+                description: this.description
+            }
+        });
         // Handle todo tests
         if (this.isTodo) {
-            const todoText = this.todoReason ? `# TODO ${this.todoReason}` : '# TODO';
-            console.log(`ok ${testNumber} - ${this.description} ${todoText}`);
+            const testResult = {
+                ok: true,
+                testNumber,
+                description: this.description,
+                directive: {
+                    type: 'todo',
+                    reason: this.todoReason
+                }
+            };
+            const lines = this.protocolEmitter.emitTest(testResult);
+            lines.forEach((line) => console.log(line));
             this.status = 'success';
+            // Emit test:completed event for todo test
+            this.emitEvent({
+                eventType: 'test:completed',
+                timestamp: Date.now(),
+                data: {
+                    testNumber,
+                    description: this.description,
+                    duration: 0,
+                    error: undefined
+                }
+            });
+            this.testDeferred.resolve(this);
+            return;
+        }
+        // Handle pre-marked skip tests
+        if (this.tapTools.isSkipped) {
+            const testResult = {
+                ok: true,
+                testNumber,
+                description: this.description,
+                directive: {
+                    type: 'skip',
+                    reason: this.tapTools.skipReason || 'Marked as skip'
+                }
+            };
+            const lines = this.protocolEmitter.emitTest(testResult);
+            lines.forEach((line) => console.log(line));
+            this.status = 'skipped';
+            // Emit test:completed event for skipped test
+            this.emitEvent({
+                eventType: 'test:completed',
+                timestamp: Date.now(),
+                data: {
+                    testNumber,
+                    description: this.description,
+                    duration: 0,
+                    error: undefined
+                }
+            });
             this.testDeferred.resolve(this);
             return;
         }
@@ -42,6 +108,18 @@ export class TapTest {
         const maxRetries = this.tapTools.maxRetries;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             this.hrtMeasurement.start();
+            // Emit test:started event
+            this.emitEvent({
+                eventType: 'test:started',
+                timestamp: Date.now(),
+                data: {
+                    testNumber,
+                    description: this.description,
+                    retry: attempt > 0 ? attempt : undefined
+                }
+            });
+            // Set protocol emitter for enhanced expect
+            setProtocolEmitter(this.protocolEmitter);
             try {
                 // Set up timeout if specified
                 let timeoutHandle;
@@ -64,8 +142,30 @@ export class TapTest {
                     clearTimeout(timeoutHandle);
                 }
                 this.hrtMeasurement.stop();
-                console.log(`ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+                const testResult = {
+                    ok: true,
+                    testNumber,
+                    description: this.description,
+                    metadata: {
+                        time: this.hrtMeasurement.milliSeconds,
+                        tags: this.tags.length > 0 ? this.tags : undefined,
+                        file: this.fileName
+                    }
+                };
+                const lines = this.protocolEmitter.emitTest(testResult);
+                lines.forEach((line) => console.log(line));
                 this.status = 'success';
+                // Emit test:completed event
+                this.emitEvent({
+                    eventType: 'test:completed',
+                    timestamp: Date.now(),
+                    data: {
+                        testNumber,
+                        description: this.description,
+                        duration: this.hrtMeasurement.milliSeconds,
+                        error: undefined
+                    }
+                });
                 this.testDeferred.resolve(this);
                 this.testResultDeferred.resolve(testReturnValue);
                 return; // Success, exit retry loop
@@ -74,20 +174,74 @@ export class TapTest {
                 this.hrtMeasurement.stop();
                 // Handle skip
                 if (err instanceof SkipError || err.name === 'SkipError') {
-                    console.log(`ok ${testNumber} - ${this.description} # SKIP ${err.message.replace('Skipped: ', '')}`);
+                    const testResult = {
+                        ok: true,
+                        testNumber,
+                        description: this.description,
+                        directive: {
+                            type: 'skip',
+                            reason: err.message.replace('Skipped: ', '')
+                        }
+                    };
+                    const lines = this.protocolEmitter.emitTest(testResult);
+                    lines.forEach((line) => console.log(line));
                     this.status = 'skipped';
+                    // Emit test:completed event for skipped test
+                    this.emitEvent({
+                        eventType: 'test:completed',
+                        timestamp: Date.now(),
+                        data: {
+                            testNumber,
+                            description: this.description,
+                            duration: this.hrtMeasurement.milliSeconds,
+                            error: undefined
+                        }
+                    });
                     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}`);
+                    console.log(this.protocolEmitter.emitComment(`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`);
+                const testResult = {
+                    ok: false,
+                    testNumber,
+                    description: this.description,
+                    metadata: {
+                        time: this.hrtMeasurement.milliSeconds,
+                        retry: this.tapTools.retryCount,
+                        maxRetries: maxRetries > 0 ? maxRetries : undefined,
+                        error: {
+                            message: lastError.message || String(lastError),
+                            stack: lastError.stack,
+                            code: lastError.code
+                        },
+                        tags: this.tags.length > 0 ? this.tags : undefined,
+                        file: this.fileName
+                    }
+                };
+                const lines = this.protocolEmitter.emitTest(testResult);
+                lines.forEach((line) => console.log(line));
+                // Emit test:completed event for failed test
+                this.emitEvent({
+                    eventType: 'test:completed',
+                    timestamp: Date.now(),
+                    data: {
+                        testNumber,
+                        description: this.description,
+                        duration: this.hrtMeasurement.milliSeconds,
+                        error: {
+                            message: lastError.message || String(lastError),
+                            stack: lastError.stack,
+                            type: 'runtime'
+                        }
+                    }
+                });
                 this.testDeferred.resolve(this);
                 this.testResultDeferred.resolve(err);
                 // if the test has already succeeded before
@@ -107,4 +261,4 @@ export class TapTest {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tapbundle.classes.taptest.js","sourceRoot":"","sources":["../ts_tapbundle/tapbundle.classes.taptest.ts"],"names":[],"mappings":"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"}

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

@@ -16,6 +16,8 @@ export declare class TapTools {
     testData: any;
     private static _sharedContext;
     private _snapshotPath;
+    private _isSkipped;
+    private _skipReason?;
     constructor(TapTestArg: TapTest<any>);
     /**
      * allow failure
@@ -25,6 +27,18 @@ export declare class TapTools {
      * skip the rest of the test
      */
     skip(reason?: string): never;
+    /**
+     * Mark test as skipped without throwing (for pre-marking)
+     */
+    markAsSkipped(reason?: string): void;
+    /**
+     * Check if test is marked as skipped
+     */
+    get isSkipped(): boolean;
+    /**
+     * Get skip reason
+     */
+    get skipReason(): string | undefined;
     /**
      * conditionally skip the rest of the test
      */

package/dist_ts_tapbundle/tapbundle.classes.taptools.js

@@ -13,6 +13,8 @@ export class TapTools {
         this._retryCount = 0;
         this.testData = {};
         this._snapshotPath = '';
+        // Flags for skip/todo
+        this._isSkipped = false;
         this.smartjson = plugins.smartjson;
         /**
          * shared context for data sharing between tests
@@ -50,9 +52,30 @@ export class TapTools {
      * skip the rest of the test
      */
     skip(reason) {
+        this._isSkipped = true;
+        this._skipReason = reason;
         const skipMessage = reason ? `Skipped: ${reason}` : 'Skipped';
         throw new SkipError(skipMessage);
     }
+    /**
+     * Mark test as skipped without throwing (for pre-marking)
+     */
+    markAsSkipped(reason) {
+        this._isSkipped = true;
+        this._skipReason = reason;
+    }
+    /**
+     * Check if test is marked as skipped
+     */
+    get isSkipped() {
+        return this._isSkipped;
+    }
+    /**
+     * Get skip reason
+     */
+    get skipReason() {
+        return this._skipReason;
+    }
     /**
      * conditionally skip the rest of the test
      */
@@ -226,4 +249,4 @@ export class TapTools {
         TapTools._fixtureData.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tapbundle.classes.taptools.js","sourceRoot":"","sources":["../ts_tapbundle/tapbundle.classes.taptools.ts"],"names":[],"mappings":"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"}

package/dist_ts_tapbundle/tapbundle.expect.wrapper.d.ts

@@ -0,0 +1,11 @@
+import { expect as smartExpect } from '@push.rocks/smartexpect';
+import { ProtocolEmitter } from '../dist_ts_tapbundle_protocol/index.js';
+/**
+ * Set the protocol emitter for enhanced error reporting
+ */
+export declare function setProtocolEmitter(emitter: ProtocolEmitter): void;
+/**
+ * Enhanced expect wrapper that captures assertion failures and generates diffs
+ */
+export declare function createEnhancedExpect(): typeof smartExpect;
+export declare const expect: typeof smartExpect;

package/dist_ts_tapbundle/tapbundle.expect.wrapper.js

@@ -0,0 +1,71 @@
+import { expect as smartExpect } from '@push.rocks/smartexpect';
+import { generateDiff } from './tapbundle.utilities.diff.js';
+import { ProtocolEmitter } from '../dist_ts_tapbundle_protocol/index.js';
+// Store the protocol emitter for event emission
+let protocolEmitter = null;
+/**
+ * Set the protocol emitter for enhanced error reporting
+ */
+export function setProtocolEmitter(emitter) {
+    protocolEmitter = emitter;
+}
+/**
+ * Enhanced expect wrapper that captures assertion failures and generates diffs
+ */
+export function createEnhancedExpect() {
+    return new Proxy(smartExpect, {
+        apply(target, thisArg, argumentsList) {
+            const expectation = target.apply(thisArg, argumentsList);
+            // Wrap common assertion methods
+            const wrappedExpectation = new Proxy(expectation, {
+                get(target, prop, receiver) {
+                    const originalValue = Reflect.get(target, prop, receiver);
+                    // Wrap assertion methods that compare values
+                    if (typeof prop === 'string' && typeof originalValue === 'function' && ['toEqual', 'toBe', 'toMatch', 'toContain'].includes(prop)) {
+                        return function (expected) {
+                            try {
+                                return originalValue.apply(target, arguments);
+                            }
+                            catch (error) {
+                                // Enhance the error with diff information
+                                const actual = argumentsList[0];
+                                const enhancedError = {
+                                    message: error.message,
+                                    stack: error.stack,
+                                    actual,
+                                    expected,
+                                    type: 'assertion'
+                                };
+                                // Generate diff if applicable
+                                if (prop === 'toEqual' || prop === 'toBe') {
+                                    const diff = generateDiff(expected, actual);
+                                    if (diff) {
+                                        enhancedError.diff = diff;
+                                    }
+                                }
+                                // Emit assertion:failed event if protocol emitter is available
+                                if (protocolEmitter) {
+                                    const event = {
+                                        eventType: 'assertion:failed',
+                                        timestamp: Date.now(),
+                                        data: {
+                                            error: enhancedError
+                                        }
+                                    };
+                                    console.log(protocolEmitter.emitEvent(event));
+                                }
+                                // Re-throw the enhanced error
+                                throw error;
+                            }
+                        };
+                    }
+                    return originalValue;
+                }
+            });
+            return wrappedExpectation;
+        }
+    });
+}
+// Create the enhanced expect function
+export const expect = createEnhancedExpect();
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle/tapbundle.interfaces.d.ts

@@ -0,0 +1,27 @@
+export interface ITapSettings {
+    timeout?: number;
+    slowThreshold?: number;
+    bail?: boolean;
+    retries?: number;
+    retryDelay?: number;
+    suppressConsole?: boolean;
+    verboseErrors?: boolean;
+    showTestDuration?: boolean;
+    maxConcurrency?: number;
+    isolateTests?: boolean;
+    beforeAll?: () => Promise<void> | void;
+    afterAll?: () => Promise<void> | void;
+    beforeEach?: (testName: string) => Promise<void> | void;
+    afterEach?: (testName: string, passed: boolean) => Promise<void> | void;
+    env?: Record<string, string>;
+    enableSnapshots?: boolean;
+    snapshotDirectory?: string;
+    updateSnapshots?: boolean;
+}
+export interface ISettingsManager {
+    getSettings(): ITapSettings;
+    setGlobalSettings(settings: ITapSettings): void;
+    setFileSettings(settings: ITapSettings): void;
+    setTestSettings(testId: string, settings: ITapSettings): void;
+    getTestSettings(testId: string): ITapSettings;
+}

package/dist_ts_tapbundle/tapbundle.interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGUvdGFwYnVuZGxlLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts_tapbundle/tapbundle.utilities.diff.d.ts

@@ -0,0 +1,5 @@
+import type { IDiffResult } from '../dist_ts_tapbundle_protocol/index.js';
+/**
+ * Generate a diff between two values
+ */
+export declare function generateDiff(expected: any, actual: any, context?: number): IDiffResult | null;