@git.zone/tstest 1.11.5 → 2.2.1

package/dist_ts_tapbundle_protocol/protocol.parser.js

@@ -0,0 +1,359 @@
+import { PROTOCOL_MARKERS } 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 class ProtocolParser {
+    constructor() {
+        this.protocolVersion = null;
+        this.inBlock = false;
+        this.blockType = null;
+        this.blockContent = [];
+    }
+    /**
+     * Parse a single line and return protocol messages
+     */
+    parseLine(line) {
+        const messages = [];
+        // Handle block content
+        if (this.inBlock) {
+            if (this.isBlockEnd(line)) {
+                messages.push(this.finalizeBlock());
+                this.inBlock = false;
+                this.blockType = null;
+                this.blockContent = [];
+            }
+            else {
+                this.blockContent.push(line);
+            }
+            return messages;
+        }
+        // Check for block start
+        if (this.isBlockStart(line)) {
+            this.inBlock = true;
+            this.blockType = this.extractBlockType(line);
+            return messages;
+        }
+        // Check for protocol version
+        const protocolVersion = this.parseProtocolVersion(line);
+        if (protocolVersion) {
+            this.protocolVersion = protocolVersion;
+            messages.push({
+                type: 'protocol',
+                content: { version: protocolVersion }
+            });
+            return messages;
+        }
+        // Parse TAP version
+        const tapVersion = this.parseTapVersion(line);
+        if (tapVersion !== null) {
+            messages.push({
+                type: 'version',
+                content: tapVersion
+            });
+            return messages;
+        }
+        // Parse plan
+        const plan = this.parsePlan(line);
+        if (plan) {
+            messages.push({
+                type: 'plan',
+                content: plan
+            });
+            return messages;
+        }
+        // Parse bailout
+        const bailout = this.parseBailout(line);
+        if (bailout) {
+            messages.push({
+                type: 'bailout',
+                content: bailout
+            });
+            return messages;
+        }
+        // Parse comment
+        if (this.isComment(line)) {
+            messages.push({
+                type: 'comment',
+                content: line.substring(2) // Remove "# "
+            });
+            return messages;
+        }
+        // Parse test result
+        const testResult = this.parseTestResult(line);
+        if (testResult) {
+            messages.push({
+                type: 'test',
+                content: testResult
+            });
+            return messages;
+        }
+        // Parse event
+        const event = this.parseEvent(line);
+        if (event) {
+            messages.push({
+                type: 'event',
+                content: event
+            });
+            return messages;
+        }
+        return messages;
+    }
+    /**
+     * Parse protocol version header
+     */
+    parseProtocolVersion(line) {
+        const match = this.extractProtocolData(line, PROTOCOL_MARKERS.PROTOCOL_PREFIX);
+        return match;
+    }
+    /**
+     * Parse TAP version line
+     */
+    parseTapVersion(line) {
+        const match = line.match(/^TAP version (\d+)$/);
+        if (match) {
+            return parseInt(match[1], 10);
+        }
+        return null;
+    }
+    /**
+     * Parse plan line
+     */
+    parsePlan(line) {
+        // Skip all plan
+        const skipMatch = line.match(/^1\.\.0\s*#\s*Skipped:\s*(.*)$/);
+        if (skipMatch) {
+            return {
+                start: 1,
+                end: 0,
+                skipAll: skipMatch[1]
+            };
+        }
+        // Normal plan
+        const match = line.match(/^(\d+)\.\.(\d+)$/);
+        if (match) {
+            return {
+                start: parseInt(match[1], 10),
+                end: parseInt(match[2], 10)
+            };
+        }
+        return null;
+    }
+    /**
+     * Parse bailout
+     */
+    parseBailout(line) {
+        const match = line.match(/^Bail out!\s*(.*)$/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Parse event
+     */
+    parseEvent(line) {
+        const eventData = this.extractProtocolData(line, PROTOCOL_MARKERS.EVENT_PREFIX);
+        if (eventData) {
+            try {
+                return JSON.parse(eventData);
+            }
+            catch (e) {
+                // Invalid JSON, ignore
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if line is a comment
+     */
+    isComment(line) {
+        return line.startsWith('# ');
+    }
+    /**
+     * Parse test result line
+     */
+    parseTestResult(line) {
+        // First extract any inline metadata
+        const metadata = this.extractInlineMetadata(line);
+        const cleanLine = this.removeInlineMetadata(line);
+        // Parse the TAP part
+        const tapMatch = cleanLine.match(/^(ok|not ok)\s+(\d+)\s*-?\s*(.*)$/);
+        if (!tapMatch) {
+            return null;
+        }
+        const result = {
+            ok: tapMatch[1] === 'ok',
+            testNumber: parseInt(tapMatch[2], 10),
+            description: tapMatch[3].trim()
+        };
+        // Parse directive
+        const directiveMatch = result.description.match(/^(.*?)\s*#\s*(SKIP|TODO)\s*(.*)$/i);
+        if (directiveMatch) {
+            result.description = directiveMatch[1].trim();
+            result.directive = {
+                type: directiveMatch[2].toLowerCase(),
+                reason: directiveMatch[3] || undefined
+            };
+        }
+        // Add metadata if found
+        if (metadata) {
+            result.metadata = metadata;
+        }
+        return result;
+    }
+    /**
+     * Extract inline metadata from line
+     */
+    extractInlineMetadata(line) {
+        const metadata = {};
+        let hasData = false;
+        // Extract skip reason
+        const skipData = this.extractProtocolData(line, PROTOCOL_MARKERS.SKIP_PREFIX);
+        if (skipData) {
+            metadata.skip = skipData;
+            hasData = true;
+        }
+        // Extract todo reason
+        const todoData = this.extractProtocolData(line, PROTOCOL_MARKERS.TODO_PREFIX);
+        if (todoData) {
+            metadata.todo = todoData;
+            hasData = true;
+        }
+        // Extract META JSON
+        const metaData = this.extractProtocolData(line, PROTOCOL_MARKERS.META_PREFIX);
+        if (metaData) {
+            try {
+                Object.assign(metadata, JSON.parse(metaData));
+                hasData = true;
+            }
+            catch (e) {
+                // Invalid JSON, ignore
+            }
+        }
+        // Extract simple key:value pairs
+        const simpleMatch = line.match(new RegExp(`${this.escapeRegex(PROTOCOL_MARKERS.START)}([^${this.escapeRegex(PROTOCOL_MARKERS.END)}]+)${this.escapeRegex(PROTOCOL_MARKERS.END)}`));
+        if (simpleMatch && !simpleMatch[1].includes(':')) {
+            // Not a prefixed format, might be key:value pairs
+            const pairs = simpleMatch[1].split(',');
+            for (const pair of pairs) {
+                const [key, value] = pair.split(':');
+                if (key && value) {
+                    if (key === 'time') {
+                        metadata.time = parseInt(value, 10);
+                        hasData = true;
+                    }
+                    else if (key === 'retry') {
+                        metadata.retry = parseInt(value, 10);
+                        hasData = true;
+                    }
+                }
+            }
+        }
+        return hasData ? metadata : null;
+    }
+    /**
+     * Remove inline metadata from line
+     */
+    removeInlineMetadata(line) {
+        // Remove all protocol markers
+        const regex = new RegExp(`${this.escapeRegex(PROTOCOL_MARKERS.START)}[^${this.escapeRegex(PROTOCOL_MARKERS.END)}]*${this.escapeRegex(PROTOCOL_MARKERS.END)}`, 'g');
+        return line.replace(regex, '').trim();
+    }
+    /**
+     * Extract protocol data with specific prefix
+     */
+    extractProtocolData(line, prefix) {
+        const regex = new RegExp(`${this.escapeRegex(PROTOCOL_MARKERS.START)}${this.escapeRegex(prefix)}([^${this.escapeRegex(PROTOCOL_MARKERS.END)}]*)${this.escapeRegex(PROTOCOL_MARKERS.END)}`);
+        const match = line.match(regex);
+        return match ? match[1] : null;
+    }
+    /**
+     * Check if line starts a block
+     */
+    isBlockStart(line) {
+        // Only match if the line is exactly the block marker (after trimming)
+        const trimmed = line.trim();
+        return trimmed === `${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.ERROR_PREFIX}${PROTOCOL_MARKERS.END}` ||
+            (trimmed.startsWith(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.SNAPSHOT_PREFIX}`) &&
+                trimmed.endsWith(PROTOCOL_MARKERS.END) &&
+                !trimmed.includes(' '));
+    }
+    /**
+     * Check if line ends a block
+     */
+    isBlockEnd(line) {
+        return line.includes(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.ERROR_END}${PROTOCOL_MARKERS.END}`) ||
+            line.includes(`${PROTOCOL_MARKERS.START}${PROTOCOL_MARKERS.SNAPSHOT_END}${PROTOCOL_MARKERS.END}`);
+    }
+    /**
+     * Extract block type from start line
+     */
+    extractBlockType(line) {
+        if (line.includes(PROTOCOL_MARKERS.ERROR_PREFIX)) {
+            return 'error';
+        }
+        if (line.includes(PROTOCOL_MARKERS.SNAPSHOT_PREFIX)) {
+            const match = line.match(new RegExp(`${this.escapeRegex(PROTOCOL_MARKERS.START)}${this.escapeRegex(PROTOCOL_MARKERS.SNAPSHOT_PREFIX)}([^${this.escapeRegex(PROTOCOL_MARKERS.END)}]*)${this.escapeRegex(PROTOCOL_MARKERS.END)}`));
+            return match ? `snapshot:${match[1]}` : 'snapshot';
+        }
+        return null;
+    }
+    /**
+     * Finalize current block
+     */
+    finalizeBlock() {
+        const content = this.blockContent.join('\n');
+        if (this.blockType === 'error') {
+            try {
+                const errorData = JSON.parse(content);
+                return {
+                    type: 'error',
+                    content: errorData
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'error',
+                    content: { error: { message: content } }
+                };
+            }
+        }
+        if (this.blockType?.startsWith('snapshot:')) {
+            const name = this.blockType.substring(9);
+            let parsedContent = content;
+            let format = 'text';
+            try {
+                parsedContent = JSON.parse(content);
+                format = 'json';
+            }
+            catch (e) {
+                // Not JSON, keep as text
+            }
+            return {
+                type: 'snapshot',
+                content: {
+                    name,
+                    content: parsedContent,
+                    format
+                }
+            };
+        }
+        // Fallback
+        return {
+            type: 'comment',
+            content: content
+        };
+    }
+    /**
+     * Escape regex special characters
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Get protocol version
+     */
+    getProtocolVersion() {
+        return this.protocolVersion;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.parser.js","sourceRoot":"","sources":["../ts_tapbundle_protocol/protocol.parser.ts"],"names":[],"mappings":"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"}

package/dist_ts_tapbundle_protocol/protocol.types.d.ts

@@ -0,0 +1,111 @@
+export interface ITestMetadata {
+    time?: number;
+    startTime?: number;
+    endTime?: number;
+    skip?: string;
+    todo?: string;
+    retry?: number;
+    maxRetries?: number;
+    error?: {
+        message: string;
+        stack?: string;
+        diff?: string;
+        actual?: any;
+        expected?: any;
+        code?: string;
+    };
+    file?: string;
+    line?: number;
+    column?: number;
+    tags?: string[];
+    custom?: Record<string, any>;
+}
+export interface ITestResult {
+    ok: boolean;
+    testNumber: number;
+    description: string;
+    directive?: {
+        type: 'skip' | 'todo';
+        reason?: string;
+    };
+    metadata?: ITestMetadata;
+}
+export interface IPlanLine {
+    start: number;
+    end: number;
+    skipAll?: string;
+}
+export interface IProtocolMessage {
+    type: 'test' | 'plan' | 'comment' | 'version' | 'bailout' | 'protocol' | 'snapshot' | 'error' | 'event';
+    content: any;
+}
+export interface IProtocolVersion {
+    version: string;
+    features?: string[];
+}
+export interface ISnapshotData {
+    name: string;
+    content: any;
+    format?: 'json' | 'text' | 'binary';
+}
+export interface IErrorBlock {
+    testNumber?: number;
+    error: {
+        message: string;
+        stack?: string;
+        diff?: string;
+        actual?: any;
+        expected?: any;
+    };
+}
+export type EventType = 'test:queued' | 'test:started' | 'test:progress' | 'test:completed' | 'suite:started' | 'suite:completed' | 'hook:started' | 'hook:completed' | 'assertion:failed';
+export interface ITestEvent {
+    eventType: EventType;
+    timestamp: number;
+    data: {
+        testNumber?: number;
+        description?: string;
+        suiteName?: string;
+        hookName?: string;
+        progress?: number;
+        duration?: number;
+        error?: IEnhancedError;
+        [key: string]: any;
+    };
+}
+export interface IEnhancedError {
+    message: string;
+    stack?: string;
+    diff?: IDiffResult;
+    actual?: any;
+    expected?: any;
+    code?: string;
+    type?: 'assertion' | 'timeout' | 'uncaught' | 'syntax' | 'runtime';
+}
+export interface IDiffResult {
+    type: 'string' | 'object' | 'array' | 'primitive';
+    changes: IDiffChange[];
+    context?: number;
+}
+export interface IDiffChange {
+    type: 'add' | 'remove' | 'modify';
+    path?: string[];
+    oldValue?: any;
+    newValue?: any;
+    line?: number;
+    content?: string;
+}
+export declare const PROTOCOL_MARKERS: {
+    readonly START: "⟦TSTEST:";
+    readonly END: "⟧";
+    readonly META_PREFIX: "META:";
+    readonly ERROR_PREFIX: "ERROR";
+    readonly ERROR_END: "/ERROR";
+    readonly SNAPSHOT_PREFIX: "SNAPSHOT:";
+    readonly SNAPSHOT_END: "/SNAPSHOT";
+    readonly PROTOCOL_PREFIX: "PROTOCOL:";
+    readonly SKIP_PREFIX: "SKIP:";
+    readonly TODO_PREFIX: "TODO:";
+    readonly EVENT_PREFIX: "EVENT:";
+};
+export declare const PROTOCOL_VERSION = "2.0.0";

package/dist_ts_tapbundle_protocol/protocol.types.js

@@ -0,0 +1,19 @@
+// Protocol V2 Types and Interfaces
+// This file contains all type definitions for the improved TAP protocol
+// Protocol markers
+export const PROTOCOL_MARKERS = {
+    START: '⟦TSTEST:',
+    END: '⟧',
+    META_PREFIX: 'META:',
+    ERROR_PREFIX: 'ERROR',
+    ERROR_END: '/ERROR',
+    SNAPSHOT_PREFIX: 'SNAPSHOT:',
+    SNAPSHOT_END: '/SNAPSHOT',
+    PROTOCOL_PREFIX: 'PROTOCOL:',
+    SKIP_PREFIX: 'SKIP:',
+    TODO_PREFIX: 'TODO:',
+    EVENT_PREFIX: 'EVENT:',
+};
+// Protocol version
+export const PROTOCOL_VERSION = '2.0.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdG9jb2wudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGVfcHJvdG9jb2wvcHJvdG9jb2wudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsbUNBQW1DO0FBQ25DLHdFQUF3RTtBQWtJeEUsbUJBQW1CO0FBQ25CLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHO0lBQzlCLEtBQUssRUFBRSxVQUFVO0lBQ2pCLEdBQUcsRUFBRSxHQUFHO0lBQ1IsV0FBVyxFQUFFLE9BQU87SUFDcEIsWUFBWSxFQUFFLE9BQU87SUFDckIsU0FBUyxFQUFFLFFBQVE7SUFDbkIsZUFBZSxFQUFFLFdBQVc7SUFDNUIsWUFBWSxFQUFFLFdBQVc7SUFDekIsZUFBZSxFQUFFLFdBQVc7SUFDNUIsV0FBVyxFQUFFLE9BQU87SUFDcEIsV0FBVyxFQUFFLE9BQU87SUFDcEIsWUFBWSxFQUFFLFFBQVE7Q0FDZCxDQUFDO0FBRVgsbUJBQW1CO0FBQ25CLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyJ9

package/npmextra.json

@@ -6,11 +6,11 @@
   "gitzone": {
     "projectType": "npm",
     "module": {
-      "githost": "gitlab.com",
-      "gitscope": "gitzone",
+      "githost": "code.foss.global",
+      "gitscope": "git.zone",
       "gitrepo": "tstest",
       "description": "a test utility to run tests that match test/**/*.ts",
-      "npmPackagename": "@gitzone/tstest",
+      "npmPackagename": "@git.zone/tstest",
       "license": "MIT"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tstest",
-  "version": "1.11.5",
+  "version": "2.2.1",
   "private": false,
   "description": "a test utility to run tests that match test/**/*.ts",
   "exports": {
@@ -25,6 +25,7 @@
     "@push.rocks/consolecolor": "^2.0.2",
     "@push.rocks/qenv": "^6.1.0",
     "@push.rocks/smartbrowser": "^2.0.8",
+    "@push.rocks/smartchok": "^1.0.34",
     "@push.rocks/smartcrypto": "^2.0.4",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartenv": "^5.0.12",