@wp-tester/results 0.0.5 → 0.1.1

package/dist/streaming.js

@@ -8,10 +8,8 @@
  * parallel test execution without output interference.
  */
 import pc from "picocolors";
-/**
- * Spinner frames for animated loader
- */
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+import { applyDiffHighlighting } from "./diff-utils.js";
+import { SPINNER_FRAMES } from "./spinner.js";
 /**
  * Default stdout writer
  */
@@ -55,6 +53,14 @@ export class StreamingReporter {
         this.showRunBoundaries = options.showRunBoundaries ?? true;
         this.showSummary = options.showSummary ?? true;
         this.enabled = options.enabled ?? true;
+        // Default filter: show all statuses (for backwards compatibility)
+        this.filter = options.filter ?? {
+            passed: true,
+            failed: true,
+            skipped: true,
+            pending: true,
+            other: true,
+        };
         this.state = {
             files: new Map(),
             toolName: "wp-tester",
@@ -63,8 +69,17 @@ export class StreamingReporter {
             passedTests: 0,
             failedTests: 0,
             skippedTests: 0,
+            pendingTests: 0,
+            isRunning: false,
         };
     }
+    /**
+     * Generate filter command for re-running a specific test
+     * Override in subclasses for framework-specific behavior
+     */
+    getFilterCommand(_testName, _suiteName) {
+        return null;
+    }
     /**
      * Enable or disable run boundaries (header and summary)
      */
@@ -154,7 +169,8 @@ export class StreamingReporter {
         let hasRunningTests = false;
         for (const file of this.state.files.values()) {
             for (const suite of file.suites) {
-                if (suite.isLoading || suite.tests.some(t => t.status === "running")) {
+                if (suite.isLoading ||
+                    suite.tests.some((t) => t.status === "running")) {
                     hasRunningTests = true;
                     break;
                 }
@@ -180,22 +196,66 @@ export class StreamingReporter {
             this.stopSpinner();
         }
     }
+    /**
+     * Check if a suite or any of its descendants has visible content
+     */
+    hasVisibleContent(file, suiteIndex) {
+        const suite = file.suites[suiteIndex];
+        // Check if suite is loading (always visible during loading)
+        if (suite.isLoading && suite.tests.length === 0) {
+            return true;
+        }
+        // Check if suite has any visible tests
+        const hasVisibleTests = suite.tests.some(test => this.shouldShowStatus(test.status));
+        if (hasVisibleTests) {
+            return true;
+        }
+        // Check if any child suites (with depth > current depth) have visible content
+        const currentDepth = suite.depth;
+        for (let i = suiteIndex + 1; i < file.suites.length; i++) {
+            const nextSuite = file.suites[i];
+            // If we've returned to the same or lower depth, we've exited the children
+            if (nextSuite.depth <= currentDepth) {
+                break;
+            }
+            // Only check immediate children (depth = current + 1)
+            if (nextSuite.depth === currentDepth + 1) {
+                if (this.hasVisibleContent(file, i)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     /**
      * Render a file's tests to output lines
      */
     renderFile(file, lines) {
-        for (const suite of file.suites) {
-            this.renderSuite(suite, lines);
+        for (let i = 0; i < file.suites.length; i++) {
+            this.renderSuite(file, i, lines);
         }
     }
     /**
      * Render a suite and its tests
      */
-    renderSuite(suite, lines) {
+    renderSuite(file, suiteIndex, lines) {
+        const suite = file.suites[suiteIndex];
         const indent = "  ".repeat(suite.depth);
         // Only show spinner if suite is loading AND has no tests yet
         // Don't show spinner if tests have been reported (loading is complete)
         const showSpinner = suite.isLoading && suite.tests.length === 0;
+        // Collect visible tests first to determine if suite should be shown
+        const visibleTestLines = [];
+        for (const test of suite.tests) {
+            if (this.shouldShowStatus(test.status)) {
+                this.renderTest(test, suite.depth + 1, visibleTestLines);
+            }
+        }
+        // Check if this suite has visible content (tests or child suites with content)
+        if (!this.hasVisibleContent(file, suiteIndex)) {
+            return; // Skip rendering this suite entirely
+        }
+        // Render the suite name
         if (showSpinner) {
             const spinner = pc.cyan(SPINNER_FRAMES[this.spinnerFrame]);
             lines.push(`${indent}${spinner} ${pc.bold(suite.name)}`);
@@ -204,10 +264,26 @@ export class StreamingReporter {
             // Use two spaces to replace the spinner character and space, preventing text shift
             lines.push(`${indent}  ${pc.bold(suite.name)}`);
         }
-        // Render tests
-        for (const test of suite.tests) {
-            this.renderTest(test, suite.depth + 1, lines);
-        }
+        // Add the visible test lines
+        lines.push(...visibleTestLines);
+    }
+    /**
+     * Check if a test status should be displayed based on filter settings
+     */
+    shouldShowStatus(status) {
+        // Always show running tests (transient state)
+        if (status === "running") {
+            return true;
+        }
+        // Map status to filter property
+        const filterMap = {
+            passed: "passed",
+            failed: "failed",
+            skipped: "skipped",
+            pending: "pending",
+        };
+        const filterKey = filterMap[status];
+        return this.filter[filterKey] ?? false;
     }
     /**
      * Render a single test
@@ -221,38 +297,96 @@ export class StreamingReporter {
                 break;
             }
             case "passed": {
-                const durationStr = test.duration ? pc.dim(` ${formatDuration(test.duration)}`) : "";
+                const durationStr = test.duration
+                    ? pc.dim(` ${formatDuration(test.duration)}`)
+                    : "";
                 lines.push(`${indent}${pc.green("✓")} ${test.name}${durationStr}`);
                 break;
             }
             case "failed": {
-                const durationStr = test.duration ? pc.dim(` ${formatDuration(test.duration)}`) : "";
+                const durationStr = test.duration
+                    ? pc.dim(` ${formatDuration(test.duration)}`)
+                    : "";
                 lines.push(`${indent}${pc.red("✗")} ${test.name}${durationStr}`);
                 if (test.message) {
                     const messageIndent = "  ".repeat(depth + 1);
-                    const indentedMessage = test.message
-                        .split("\n")
-                        .map((line) => `${messageIndent}${pc.red(line)}`)
-                        .join("\n");
-                    lines.push(indentedMessage);
+                    for (const line of test.message.split("\n")) {
+                        lines.push(`${messageIndent}${pc.red(line)}`);
+                    }
                 }
                 if (test.trace) {
                     const traceIndent = "  ".repeat(depth + 1);
-                    const indentedTrace = test.trace
-                        .split("\n")
-                        .map((line) => `${traceIndent}${pc.dim(line)}`)
-                        .join("\n");
-                    lines.push(indentedTrace);
+                    const traceLines = test.trace.split("\n");
+                    for (let i = 0; i < traceLines.length; i++) {
+                        const line = traceLines[i];
+                        const trimmed = line.trim();
+                        // Detect Expected/Actual labels and color the values (supports multiline values)
+                        if (trimmed === "Expected:" && i + 1 < traceLines.length) {
+                            lines.push(`${traceIndent}${pc.dim("Expected:")}`);
+                            i++; // Move to the first value line
+                            // Continue processing lines until we hit Actual:, an empty line, or end of trace
+                            while (i < traceLines.length) {
+                                const valueLine = traceLines[i];
+                                const valueTrimmed = valueLine.trim();
+                                // Stop if we hit the Actual: label or empty line
+                                if (valueTrimmed === "Actual:" || valueTrimmed === "") {
+                                    i--; // Back up so the outer loop can process this line
+                                    break;
+                                }
+                                if (valueTrimmed) {
+                                    lines.push(`${traceIndent}${applyDiffHighlighting(valueLine, pc.red)}`);
+                                }
+                                i++;
+                            }
+                        }
+                        else if (trimmed === "Actual:" && i + 1 < traceLines.length) {
+                            lines.push(`${traceIndent}${pc.dim("Actual:")}`);
+                            i++; // Move to the first value line
+                            // Continue processing lines until we hit an empty line or end of trace
+                            while (i < traceLines.length) {
+                                const valueLine = traceLines[i];
+                                const valueTrimmed = valueLine.trim();
+                                // Stop if we hit an empty line
+                                if (valueTrimmed === "") {
+                                    i--; // Back up so the outer loop can process this line
+                                    break;
+                                }
+                                if (valueTrimmed) {
+                                    lines.push(`${traceIndent}${applyDiffHighlighting(valueLine, pc.green)}`);
+                                }
+                                i++;
+                            }
+                        }
+                        else if (trimmed) {
+                            // File paths, context lines, other trace info
+                            lines.push(`${traceIndent}${pc.dim(line)}`);
+                        }
+                        else {
+                            // Empty lines (preserve them for spacing)
+                            lines.push("");
+                        }
+                    }
+                    // Add filter to re-run this specific test
+                    if (test.name) {
+                        const filterCmd = this.getFilterCommand(test.name, test.suiteName);
+                        if (filterCmd) {
+                            lines.push(`${traceIndent}${pc.dim("Re-run only this test by appending:")}`);
+                            lines.push(`${traceIndent}${pc.dim(filterCmd)}`);
+                        }
+                    }
                 }
                 break;
             }
             case "skipped": {
-                const reasonStr = test.message ? ` ${pc.dim(`(${test.message})`)}` : "";
+                const reasonStr = test.message
+                    ? ` ${pc.dim(`(${test.message})`)}`
+                    : ` ${pc.dim("(Skipped)")}`;
                 lines.push(`${indent}${pc.yellow("○")} ${pc.dim(test.name)}${reasonStr}`);
                 break;
             }
             case "pending": {
-                lines.push(`${indent}${pc.yellow("○")} ${pc.dim(test.name)}`);
+                const message = test.message ? ` ${pc.dim(`(${test.message})`)}` : "";
+                lines.push(`${indent}${pc.yellow("◔")} ${pc.dim(test.name)}${message}`);
                 break;
             }
         }
@@ -278,7 +412,7 @@ export class StreamingReporter {
      */
     getOrCreateSuite(file, suiteName) {
         // Find existing suite
-        let suite = file.suites.find(s => s.name === suiteName);
+        let suite = file.suites.find((s) => s.name === suiteName);
         if (!suite) {
             suite = {
                 name: suiteName,
@@ -290,18 +424,33 @@ export class StreamingReporter {
         }
         return suite;
     }
+    /**
+     * Get display name from tool name
+     */
+    getDisplayName(toolName) {
+        const nameMap = {
+            "wp-tester-phpunit": "PHPUnit Tests",
+            "wp-tester-smoke": "WordPress Tests",
+            "wp-tester": "Tests",
+        };
+        return nameMap[toolName] || toolName;
+    }
     /**
      * Called when test run starts
      */
     onRunStart(toolName) {
+        const tool = toolName || "wp-tester";
         this.state = {
             files: new Map(),
-            toolName: toolName || "wp-tester",
+            toolName: tool,
+            displayName: this.getDisplayName(tool),
             startTime: Date.now(),
             totalTests: 0,
             passedTests: 0,
             failedTests: 0,
             skippedTests: 0,
+            pendingTests: 0,
+            isRunning: true,
         };
         this.lastOutputLineCount = 0;
     }
@@ -310,6 +459,7 @@ export class StreamingReporter {
      */
     onRunEnd() {
         this.stopSpinner();
+        this.state.isRunning = false;
         // Clean up any tests still in "running" state across all files
         // This ensures we never show spinners in the final output
         for (const file of this.state.files.values()) {
@@ -318,6 +468,9 @@ export class StreamingReporter {
                 for (const test of suite.tests) {
                     if (test.status === "running") {
                         test.status = "pending";
+                        test.message = test.message || "Did not complete";
+                        this.state.pendingTests++;
+                        this.state.totalTests++;
                     }
                 }
             }
@@ -347,7 +500,9 @@ export class StreamingReporter {
      * Called when a test suite starts
      */
     onSuiteStart(name, fileId) {
-        const file = fileId ? this.getOrCreateFile(fileId) : this.getOrCreateFile("__global__");
+        const file = fileId
+            ? this.getOrCreateFile(fileId)
+            : this.getOrCreateFile("__global__");
         file.currentSuiteStack.push(name);
         const suite = this.getOrCreateSuite(file, name);
         // When a child suite is created, mark all parent suites as not loading
@@ -363,7 +518,9 @@ export class StreamingReporter {
      * Called when a test suite ends
      */
     onSuiteEnd(name, fileId) {
-        const file = fileId ? this.state.files.get(fileId) : this.state.files.get("__global__");
+        const file = fileId
+            ? this.state.files.get(fileId)
+            : this.state.files.get("__global__");
         if (file) {
             const index = file.currentSuiteStack.lastIndexOf(name);
             if (index !== -1) {
@@ -371,7 +528,7 @@ export class StreamingReporter {
             }
             // Mark suite as no longer loading when it ends
             // This ensures loaders are removed even if no tests were reported
-            const suite = file.suites.find(s => s.name === name);
+            const suite = file.suites.find((s) => s.name === name);
             if (suite) {
                 suite.isLoading = false;
                 // Clean up any tests still in "running" state - they should be marked as pending
@@ -379,6 +536,9 @@ export class StreamingReporter {
                 for (const test of suite.tests) {
                     if (test.status === "running") {
                         test.status = "pending";
+                        test.message = test.message || "Did not complete";
+                        this.state.pendingTests++;
+                        this.state.totalTests++;
                     }
                 }
             }
@@ -389,42 +549,55 @@ export class StreamingReporter {
      * Called when a test starts
      */
     onTestStart(name, suiteName, fileId) {
-        const file = fileId ? this.getOrCreateFile(fileId) : this.getOrCreateFile("__global__");
+        const file = fileId
+            ? this.getOrCreateFile(fileId)
+            : this.getOrCreateFile("__global__");
         const suite = this.getOrCreateSuite(file, suiteName || "Tests");
         // Mark ALL suites in this file as no longer loading once any test starts
         // This handles nested suite structures where parent suites don't directly contain tests
         for (const s of file.suites) {
             s.isLoading = false;
         }
-        suite.tests.push({
-            name,
-            suiteName,
-            status: "running",
-        });
+        // Check if test already exists (completion event arrived before start event)
+        const existingTest = suite.tests.find((t) => t.name === name && t.suiteName === suiteName);
+        if (!existingTest) {
+            // Test doesn't exist yet - create it in running state
+            suite.tests.push({
+                name,
+                suiteName,
+                status: "running",
+            });
+        }
+        // If test already exists with a completed status, don't change it
         this.render();
     }
     /**
      * Called when a test passes
      */
     onTestPass(name, duration, suiteName, fileId) {
-        const file = fileId ? this.getOrCreateFile(fileId) : this.getOrCreateFile("__global__");
+        const file = fileId
+            ? this.getOrCreateFile(fileId)
+            : this.getOrCreateFile("__global__");
         const suite = this.getOrCreateSuite(file, suiteName || "Tests");
         // Mark ALL suites in this file as no longer loading once any test completes
         // This handles nested suite structures where parent suites don't directly contain tests
         for (const s of file.suites) {
             s.isLoading = false;
         }
-        // Find and update the test - try exact match first, then fallback to name-only match
-        let test = suite.tests.find(t => t.name === name && t.suiteName === suiteName);
+        // Find and update the test
+        // Look for a test in "running" state first (most common case - completion follows start)
+        let test = suite.tests.find((t) => t.name === name && t.status === "running");
         if (!test) {
-            // Fallback: try to find by name only (handles cases where suiteName might differ)
-            test = suite.tests.find(t => t.name === name && t.status === "running");
+            // Fallback: try exact match with suiteName (handles case where test completed before start event)
+            test = suite.tests.find((t) => t.name === name && t.suiteName === suiteName);
         }
         if (test) {
             test.status = "passed";
             test.duration = duration;
+            test.suiteName = suiteName; // Ensure suiteName is set
         }
         else {
+            // Test start event hasn't arrived yet - create the test with completed state
             suite.tests.push({
                 name,
                 suiteName,
@@ -440,26 +613,31 @@ export class StreamingReporter {
      * Called when a test fails
      */
     onTestFail(name, duration, message, trace, suiteName, fileId) {
-        const file = fileId ? this.getOrCreateFile(fileId) : this.getOrCreateFile("__global__");
+        const file = fileId
+            ? this.getOrCreateFile(fileId)
+            : this.getOrCreateFile("__global__");
         const suite = this.getOrCreateSuite(file, suiteName || "Tests");
         // Mark ALL suites in this file as no longer loading once any test completes
         // This handles nested suite structures where parent suites don't directly contain tests
         for (const s of file.suites) {
             s.isLoading = false;
         }
-        // Find and update the test - try exact match first, then fallback to name-only match
-        let test = suite.tests.find(t => t.name === name && t.suiteName === suiteName);
+        // Find and update the test
+        // Look for a test in "running" state first (most common case - completion follows start)
+        let test = suite.tests.find((t) => t.name === name && t.status === "running");
         if (!test) {
-            // Fallback: try to find by name only (handles cases where suiteName might differ)
-            test = suite.tests.find(t => t.name === name && t.status === "running");
+            // Fallback: try exact match with suiteName (handles case where test completed before start event)
+            test = suite.tests.find((t) => t.name === name && t.suiteName === suiteName);
         }
         if (test) {
             test.status = "failed";
             test.duration = duration;
             test.message = message;
             test.trace = trace;
+            test.suiteName = suiteName; // Ensure suiteName is set
         }
         else {
+            // Test start event hasn't arrived yet - create the test with completed state
             suite.tests.push({
                 name,
                 suiteName,
@@ -477,24 +655,29 @@ export class StreamingReporter {
      * Called when a test is skipped
      */
     onTestSkip(name, reason, suiteName, fileId) {
-        const file = fileId ? this.getOrCreateFile(fileId) : this.getOrCreateFile("__global__");
+        const file = fileId
+            ? this.getOrCreateFile(fileId)
+            : this.getOrCreateFile("__global__");
         const suite = this.getOrCreateSuite(file, suiteName || "Tests");
         // Mark ALL suites in this file as no longer loading once any test completes
         // This handles nested suite structures where parent suites don't directly contain tests
         for (const s of file.suites) {
             s.isLoading = false;
         }
-        // Find and update the test - try exact match first, then fallback to name-only match
-        let test = suite.tests.find(t => t.name === name && t.suiteName === suiteName);
+        // Find and update the test
+        // Look for a test in "running" state first (most common case - completion follows start)
+        let test = suite.tests.find((t) => t.name === name && t.status === "running");
         if (!test) {
-            // Fallback: try to find by name only (handles cases where suiteName might differ)
-            test = suite.tests.find(t => t.name === name && t.status === "running");
+            // Fallback: try exact match with suiteName (handles case where test completed before start event)
+            test = suite.tests.find((t) => t.name === name && t.suiteName === suiteName);
         }
         if (test) {
             test.status = "skipped";
             test.message = reason;
+            test.suiteName = suiteName; // Ensure suiteName is set
         }
         else {
+            // Test start event hasn't arrived yet - create the test with completed state
             suite.tests.push({
                 name,
                 suiteName,
@@ -510,12 +693,14 @@ export class StreamingReporter {
      * Called when a test is pending
      */
     onTestPending(name, suiteName, fileId) {
-        const file = fileId ? this.getOrCreateFile(fileId) : this.getOrCreateFile("__global__");
+        const file = fileId
+            ? this.getOrCreateFile(fileId)
+            : this.getOrCreateFile("__global__");
         const suite = this.getOrCreateSuite(file, suiteName || "Tests");
         // Mark suite as no longer loading once first test completes
         suite.isLoading = false;
         // Find and update the test
-        const test = suite.tests.find(t => t.name === name && t.suiteName === suiteName);
+        const test = suite.tests.find((t) => t.name === name && t.suiteName === suiteName);
         if (test) {
             test.status = "pending";
         }
@@ -543,9 +728,15 @@ export class StreamingReporter {
         if (this.state.skippedTests > 0) {
             this.writer.writeLine(pc.yellow(`  ○ ${this.state.skippedTests} skipped`));
         }
+        if (this.state.pendingTests > 0) {
+            this.writer.writeLine(pc.yellow(`  ◔ ${this.state.pendingTests} pending`));
+        }
         this.writer.writeLine("");
         this.writer.writeLine(pc.dim(`  ${this.state.totalTests} tests in ${formatDuration(duration)}`));
         this.writer.writeLine("");
+        // Print icon legend
+        this.writer.writeLine(pc.dim("  Legend: ✓ passed  ✗ failed  ○ skipped  ◔ pending"));
+        this.writer.writeLine("");
     }
     /**
      * Get the current report in CTRF format
@@ -557,7 +748,9 @@ export class StreamingReporter {
             for (const suite of file.suites) {
                 for (const test of suite.tests) {
                     const ctrf = {
-                        name: test.suiteName ? `${test.suiteName}::${test.name}` : test.name,
+                        name: test.suiteName
+                            ? `${test.suiteName}::${test.name}`
+                            : test.name,
                         status: test.status === "running" ? "other" : test.status,
                         duration: test.duration || 0,
                     };
@@ -583,7 +776,7 @@ export class StreamingReporter {
                     passed: this.state.passedTests,
                     failed: this.state.failedTests,
                     skipped: this.state.skippedTests,
-                    pending: 0,
+                    pending: this.state.pendingTests,
                     other: 0,
                     start: this.state.startTime,
                     stop: Date.now(),
@@ -601,6 +794,7 @@ export class StreamingReporter {
             passed: this.state.passedTests,
             failed: this.state.failedTests,
             skipped: this.state.skippedTests,
+            pending: this.state.pendingTests,
         };
     }
 }