@git.zone/tstest 1.11.5 → 2.2.0

package/dist_ts_tapbundle/tapbundle.utilities.diff.js

@@ -0,0 +1,179 @@
+/**
+ * Generate a diff between two values
+ */
+export function generateDiff(expected, actual, context = 3) {
+    // Handle same values
+    if (expected === actual) {
+        return null;
+    }
+    // Determine diff type based on values
+    if (typeof expected === 'string' && typeof actual === 'string') {
+        return generateStringDiff(expected, actual, context);
+    }
+    else if (Array.isArray(expected) && Array.isArray(actual)) {
+        return generateArrayDiff(expected, actual);
+    }
+    else if (expected && actual && typeof expected === 'object' && typeof actual === 'object') {
+        return generateObjectDiff(expected, actual);
+    }
+    else {
+        return generatePrimitiveDiff(expected, actual);
+    }
+}
+/**
+ * Generate diff for primitive values
+ */
+function generatePrimitiveDiff(expected, actual) {
+    return {
+        type: 'primitive',
+        changes: [{
+                type: 'modify',
+                oldValue: expected,
+                newValue: actual
+            }]
+    };
+}
+/**
+ * Generate diff for strings (line-by-line)
+ */
+function generateStringDiff(expected, actual, context) {
+    const expectedLines = expected.split('\n');
+    const actualLines = actual.split('\n');
+    const changes = [];
+    // Simple line-by-line diff
+    const maxLines = Math.max(expectedLines.length, actualLines.length);
+    for (let i = 0; i < maxLines; i++) {
+        const expectedLine = expectedLines[i];
+        const actualLine = actualLines[i];
+        if (expectedLine === undefined) {
+            changes.push({
+                type: 'add',
+                line: i,
+                content: actualLine
+            });
+        }
+        else if (actualLine === undefined) {
+            changes.push({
+                type: 'remove',
+                line: i,
+                content: expectedLine
+            });
+        }
+        else if (expectedLine !== actualLine) {
+            changes.push({
+                type: 'remove',
+                line: i,
+                content: expectedLine
+            });
+            changes.push({
+                type: 'add',
+                line: i,
+                content: actualLine
+            });
+        }
+    }
+    return {
+        type: 'string',
+        changes,
+        context
+    };
+}
+/**
+ * Generate diff for arrays
+ */
+function generateArrayDiff(expected, actual) {
+    const changes = [];
+    const maxLength = Math.max(expected.length, actual.length);
+    for (let i = 0; i < maxLength; i++) {
+        const expectedItem = expected[i];
+        const actualItem = actual[i];
+        if (i >= expected.length) {
+            changes.push({
+                type: 'add',
+                path: [String(i)],
+                newValue: actualItem
+            });
+        }
+        else if (i >= actual.length) {
+            changes.push({
+                type: 'remove',
+                path: [String(i)],
+                oldValue: expectedItem
+            });
+        }
+        else if (!deepEqual(expectedItem, actualItem)) {
+            changes.push({
+                type: 'modify',
+                path: [String(i)],
+                oldValue: expectedItem,
+                newValue: actualItem
+            });
+        }
+    }
+    return {
+        type: 'array',
+        changes
+    };
+}
+/**
+ * Generate diff for objects
+ */
+function generateObjectDiff(expected, actual) {
+    const changes = [];
+    const allKeys = new Set([...Object.keys(expected), ...Object.keys(actual)]);
+    for (const key of allKeys) {
+        const expectedValue = expected[key];
+        const actualValue = actual[key];
+        if (!(key in expected)) {
+            changes.push({
+                type: 'add',
+                path: [key],
+                newValue: actualValue
+            });
+        }
+        else if (!(key in actual)) {
+            changes.push({
+                type: 'remove',
+                path: [key],
+                oldValue: expectedValue
+            });
+        }
+        else if (!deepEqual(expectedValue, actualValue)) {
+            changes.push({
+                type: 'modify',
+                path: [key],
+                oldValue: expectedValue,
+                newValue: actualValue
+            });
+        }
+    }
+    return {
+        type: 'object',
+        changes
+    };
+}
+/**
+ * Deep equality check
+ */
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a === 'object') {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            return a.every((item, index) => deepEqual(item, b[index]));
+        }
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        return keysA.every(key => deepEqual(a[key], b[key]));
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle_protocol/index.d.ts

@@ -0,0 +1,6 @@
+export * from './protocol.types.js';
+export * from './protocol.emitter.js';
+export * from './protocol.parser.js';
+export { ProtocolEmitter } from './protocol.emitter.js';
+export { ProtocolParser } from './protocol.parser.js';
+export { PROTOCOL_MARKERS, PROTOCOL_VERSION } from './protocol.types.js';

package/dist_ts_tapbundle_protocol/index.js

@@ -0,0 +1,11 @@
+// Protocol V2 - Isomorphic implementation for improved TAP protocol
+// This module is designed to work in both browser and Node.js environments
+export * from './protocol.types.js';
+export * from './protocol.emitter.js';
+export * from './protocol.parser.js';
+// Re-export main classes for convenience
+export { ProtocolEmitter } from './protocol.emitter.js';
+export { ProtocolParser } from './protocol.parser.js';
+// Re-export constants
+export { PROTOCOL_MARKERS, PROTOCOL_VERSION } from './protocol.types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGVfcHJvdG9jb2wvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0VBQW9FO0FBQ3BFLDJFQUEyRTtBQUUzRSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUVyQyx5Q0FBeUM7QUFDekMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV0RCxzQkFBc0I7QUFDdEIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGdCQUFnQixFQUFFLE1BQU0scUJBQXFCLENBQUMifQ==

package/dist_ts_tapbundle_protocol/protocol.emitter.d.ts

@@ -0,0 +1,55 @@
+import type { ITestResult, IPlanLine, ISnapshotData, IErrorBlock, ITestEvent } from './protocol.types.js';
+/**
+ * ProtocolEmitter generates Protocol V2 messages
+ * This class is used by tapbundle to emit test results in the new protocol format
+ */
+export declare class ProtocolEmitter {
+    /**
+     * Emit protocol version header
+     */
+    emitProtocolHeader(): string;
+    /**
+     * Emit TAP version line
+     */
+    emitTapVersion(version?: number): string;
+    /**
+     * Emit test plan
+     */
+    emitPlan(plan: IPlanLine): string;
+    /**
+     * Emit a test result
+     */
+    emitTest(result: ITestResult): string[];
+    /**
+     * Emit a comment line
+     */
+    emitComment(comment: string): string;
+    /**
+     * Emit bailout
+     */
+    emitBailout(reason: string): string;
+    /**
+     * Emit snapshot data
+     */
+    emitSnapshot(snapshot: ISnapshotData): string[];
+    /**
+     * Emit error block
+     */
+    emitError(error: IErrorBlock): string[];
+    /**
+     * Emit test event
+     */
+    emitEvent(event: ITestEvent): string;
+    /**
+     * Check if metadata should be inline
+     */
+    private shouldUseInlineMetadata;
+    /**
+     * Create inline metadata string
+     */
+    private createInlineMetadata;
+    /**
+     * Create block metadata lines
+     */
+    private createBlockMetadata;
+}

package/dist_ts_tapbundle_protocol/protocol.emitter.js

@@ -0,0 +1,155 @@
+import { PROTOCOL_MARKERS, PROTOCOL_VERSION } from './protocol.types.js';
+/**
+ * ProtocolEmitter generates Protocol V2 messages
+ * This class is used by tapbundle to emit test results in the new protocol format
+ */
+export class ProtocolEmitter {
+    /**
+     * Emit protocol version header
+     */
+    emitProtocolHeader() {
+        return `${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.PROTOCOL_PREFIX}${PROTOCOL_VERSION}${PROTOCOL_MARKERS.END}`;
+    }
+    /**
+     * Emit TAP version line
+     */
+    emitTapVersion(version = 13) {
+        return `TAP version ${version}`;
+    }
+    /**
+     * Emit test plan
+     */
+    emitPlan(plan) {
+        if (plan.skipAll) {
+            return `1..0 # Skipped: ${plan.skipAll}`;
+        }
+        return `${plan.start}..${plan.end}`;
+    }
+    /**
+     * Emit a test result
+     */
+    emitTest(result) {
+        const lines = [];
+        // Build the basic TAP line
+        let tapLine = result.ok ? 'ok' : 'not ok';
+        tapLine += ` ${result.testNumber}`;
+        tapLine += ` - ${result.description}`;
+        // Add directive if present
+        if (result.directive) {
+            tapLine += ` # ${result.directive.type.toUpperCase()}`;
+            if (result.directive.reason) {
+                tapLine += ` ${result.directive.reason}`;
+            }
+        }
+        // Add inline metadata for simple cases
+        if (result.metadata && this.shouldUseInlineMetadata(result.metadata)) {
+            const metaStr = this.createInlineMetadata(result.metadata);
+            if (metaStr) {
+                tapLine += ` ${metaStr}`;
+            }
+        }
+        lines.push(tapLine);
+        // Add block metadata for complex cases
+        if (result.metadata && !this.shouldUseInlineMetadata(result.metadata)) {
+            lines.push(...this.createBlockMetadata(result.metadata, result.testNumber));
+        }
+        return lines;
+    }
+    /**
+     * Emit a comment line
+     */
+    emitComment(comment) {
+        return `# ${comment}`;
+    }
+    /**
+     * Emit bailout
+     */
+    emitBailout(reason) {
+        return `Bail out! ${reason}`;
+    }
+    /**
+     * Emit snapshot data
+     */
+    emitSnapshot(snapshot) {
+        const lines = [];
+        lines.push(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.SNAPSHOT_PREFIX}${snapshot.name}${PROTOCOL_MARKERS.END}`);
+        if (snapshot.format === 'json') {
+            lines.push(JSON.stringify(snapshot.content, null, 2));
+        }
+        else {
+            lines.push(String(snapshot.content));
+        }
+        lines.push(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.SNAPSHOT_END}${PROTOCOL_MARKERS.END}`);
+        return lines;
+    }
+    /**
+     * Emit error block
+     */
+    emitError(error) {
+        const lines = [];
+        lines.push(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.ERROR_PREFIX}${PROTOCOL_MARKERS.END}`);
+        lines.push(JSON.stringify(error, null, 2));
+        lines.push(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.ERROR_END}${PROTOCOL_MARKERS.END}`);
+        return lines;
+    }
+    /**
+     * Emit test event
+     */
+    emitEvent(event) {
+        const eventJson = JSON.stringify(event);
+        return `${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.EVENT_PREFIX}${eventJson}${PROTOCOL_MARKERS.END}`;
+    }
+    /**
+     * Check if metadata should be inline
+     */
+    shouldUseInlineMetadata(metadata) {
+        // Use inline for simple metadata (time, retry, simple skip/todo)
+        const hasComplexData = metadata.error ||
+            metadata.custom ||
+            (metadata.tags && metadata.tags.length > 0) ||
+            metadata.file ||
+            metadata.line;
+        return !hasComplexData;
+    }
+    /**
+     * Create inline metadata string
+     */
+    createInlineMetadata(metadata) {
+        const parts = [];
+        if (metadata.time !== undefined) {
+            parts.push(`time:${metadata.time}`);
+        }
+        if (metadata.retry !== undefined) {
+            parts.push(`retry:${metadata.retry}`);
+        }
+        if (metadata.skip) {
+            return `${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.SKIP_PREFIX}${metadata.skip}${PROTOCOL_MARKERS.END}`;
+        }
+        if (metadata.todo) {
+            return `${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.TODO_PREFIX}${metadata.todo}${PROTOCOL_MARKERS.END}`;
+        }
+        if (parts.length > 0) {
+            return `${PROTOCOL_MARKERS.START}${parts.join(',')}${PROTOCOL_MARKERS.END}`;
+        }
+        return '';
+    }
+    /**
+     * Create block metadata lines
+     */
+    createBlockMetadata(metadata, testNumber) {
+        const lines = [];
+        // Create a clean metadata object without skip/todo (handled inline)
+        const blockMeta = { ...metadata };
+        delete blockMeta.skip;
+        delete blockMeta.todo;
+        // Emit metadata block
+        const metaJson = JSON.stringify(blockMeta);
+        lines.push(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.META_PREFIX}${metaJson}${PROTOCOL_MARKERS.END}`);
+        // Emit separate error block if present
+        if (metadata.error) {
+            lines.push(...this.emitError({ testNumber, error: metadata.error }));
+        }
+        return lines;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle_protocol/protocol.parser.d.ts

@@ -0,0 +1,79 @@
+import type { IProtocolMessage } from './protocol.types.js';
+/**
+ * ProtocolParser parses Protocol V2 messages
+ * This class is used by tstest to parse test results from the new protocol format
+ */
+export declare class ProtocolParser {
+    private protocolVersion;
+    private inBlock;
+    private blockType;
+    private blockContent;
+    /**
+     * Parse a single line and return protocol messages
+     */
+    parseLine(line: string): IProtocolMessage[];
+    /**
+     * Parse protocol version header
+     */
+    private parseProtocolVersion;
+    /**
+     * Parse TAP version line
+     */
+    private parseTapVersion;
+    /**
+     * Parse plan line
+     */
+    private parsePlan;
+    /**
+     * Parse bailout
+     */
+    private parseBailout;
+    /**
+     * Parse event
+     */
+    private parseEvent;
+    /**
+     * Check if line is a comment
+     */
+    private isComment;
+    /**
+     * Parse test result line
+     */
+    private parseTestResult;
+    /**
+     * Extract inline metadata from line
+     */
+    private extractInlineMetadata;
+    /**
+     * Remove inline metadata from line
+     */
+    private removeInlineMetadata;
+    /**
+     * Extract protocol data with specific prefix
+     */
+    private extractProtocolData;
+    /**
+     * Check if line starts a block
+     */
+    private isBlockStart;
+    /**
+     * Check if line ends a block
+     */
+    private isBlockEnd;
+    /**
+     * Extract block type from start line
+     */
+    private extractBlockType;
+    /**
+     * Finalize current block
+     */
+    private finalizeBlock;
+    /**
+     * Escape regex special characters
+     */
+    private escapeRegex;
+    /**
+     * Get protocol version
+     */
+    getProtocolVersion(): string | null;
+}