@testspectra/cli 1.0.69 → 1.1.0-rc.0

package/dist/runner/bridge.js

@@ -1,19 +1,25 @@
-import { spawn } from "child_process";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class RustCoreBridge {
     static resolveBinaryPath() {
         // 1. Look for precompiled release/debug binary in workspace target
-        const workspaceRoot = path.resolve(__dirname, "../../..");
+        const workspaceRoot = path.resolve(__dirname, '../../..');
+        const isWindows = process.platform === 'win32';
+        const binaryName = isWindows ? 'testspectra-runner.exe' : 'testspectra-runner';
         const candidatePaths = [
-            path.join(workspaceRoot, "target/debug/testspectra-runner"),
-            path.join(workspaceRoot, "target/release/testspectra-runner"),
-            path.join(workspaceRoot, "core/test-runner/target/debug/testspectra-runner"),
-            path.join(workspaceRoot, "core/test-runner/target/release/testspectra-runner"),
-            path.join(__dirname, "../../bin/testspectra-runner"),
+            path.join(workspaceRoot, 'core/target/release', binaryName),
+            path.join(workspaceRoot, 'target/release', binaryName),
+            path.join(workspaceRoot, 'cli/bin', binaryName),
+            path.join(__dirname, '../../bin', binaryName),
+            path.join(workspaceRoot, 'core/cli/target/release', binaryName),
+            path.join(workspaceRoot, 'core/target/debug', binaryName),
+            path.join(workspaceRoot, 'target/debug', binaryName),
+            path.join(workspaceRoot, 'core/cli/target/debug', binaryName),
+            path.join(__dirname, '../../bin/testspectra-runner'),
         ];
         for (const p of candidatePaths) {
             if (fs.existsSync(p)) {
@@ -23,7 +29,8 @@ export class RustCoreBridge {
                 return `${p}.exe`;
             }
         }
-        return "cargo"; // Fallback to cargo run
+        throw new Error("[TestSpectra] Native core runner binary 'testspectra-runner' not found.\n" +
+            "Please build the project first using 'pnpm run build' or 'pnpm run build:core'.");
     }
     static async run(options, reporter) {
         const binPath = this.resolveBinaryPath();
@@ -35,9 +42,15 @@ export class RustCoreBridge {
             testCases: options.testCases,
             config: options.config,
             targetDevice: options.targetDevice,
+            licenseKey: options.licenseKey,
+            outputJsonPath: options.outputJsonPath,
+            specs: options.specs,
+            concurrency: options.concurrency,
+            failedOnly: options.failedOnly,
+            failedTarget: options.failedTarget,
         });
-        const home = process.env.HOME || process.env.USERPROFILE || "";
-        const globalDriversDir = path.join(home, ".testspectra", "drivers");
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const globalDriversDir = path.join(home, '.testspectra', 'drivers');
         if (!fs.existsSync(globalDriversDir)) {
             try {
                 fs.mkdirSync(globalDriversDir, { recursive: true });
@@ -47,39 +60,47 @@ export class RustCoreBridge {
         const runnerEnv = {
             ...process.env,
             TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
-            RUST_LOG: "info",
+            RUST_LOG: 'info',
         };
+        const runStartedAt = Date.now();
         return new Promise((resolve, reject) => {
-            let child;
-            if (binPath === "cargo") {
-                const workspaceRoot = path.resolve(__dirname, "../../..");
-                child = spawn("cargo", ["run", "--manifest-path", "core/test-runner/Cargo.toml", "--bin", "testspectra-runner", "--", payload], {
-                    cwd: workspaceRoot,
-                    env: runnerEnv,
-                });
-            }
-            else {
-                child = spawn(binPath, [payload], {
-                    env: runnerEnv,
-                });
-            }
-            let runStatus = "failed";
-            let runDuration = "0s";
-            child.stdout.on("data", (data) => {
-                const lines = data.toString().split("\n");
+            const child = spawn(binPath, [payload], {
+                env: runnerEnv,
+            });
+            let runStatus = 'failed';
+            let runDuration = '0s';
+            child.stdout.on('data', (data) => {
+                const lines = data.toString().split('\n');
                 for (const line of lines) {
                     if (!line.trim())
                         continue;
+                    if (line.startsWith('[TESTSPECTRA_')) {
+                        reporter.addLog({
+                            timestamp: new Date().toLocaleTimeString(),
+                            level: 'INFO',
+                            message: line,
+                        });
+                        // In interactive terminals, the reporter above already renders this tag as part of
+                        // its live-updating spinner UI (`renderActiveSlots`), so echoing the raw tag too would
+                        // just duplicate/clutter that UI. But that live rendering is a no-op when stdout isn't
+                        // a real TTY (CI, or an external tool like the VS Code extension spawning this process
+                        // via a pipe) — in that case this raw line is the *only* live signal a wrapping process
+                        // can see, so it must still reach stdout verbatim.
+                        if (!reporter.isInteractiveMode()) {
+                            console.log(line);
+                        }
+                        continue;
+                    }
                     try {
                         const parsed = JSON.parse(line);
-                        if (parsed.type === "log") {
+                        if (parsed.type === 'log') {
                             reporter.addLog({
                                 timestamp: parsed.timestamp,
                                 level: parsed.level,
                                 message: parsed.message,
                             });
                         }
-                        else if (parsed.type === "network") {
+                        else if (parsed.type === 'network') {
                             reporter.addNetwork({
                                 requestId: parsed.requestId,
                                 url: parsed.url,
@@ -87,14 +108,14 @@ export class RustCoreBridge {
                                 status: parsed.status,
                             });
                         }
-                        else if (parsed.type === "complete") {
+                        else if (parsed.type === 'complete') {
                             runStatus = parsed.status;
                             runDuration = parsed.duration;
                         }
-                        else if (parsed.type === "error") {
+                        else if (parsed.type === 'error') {
                             reporter.addLog({
                                 timestamp: new Date().toLocaleTimeString(),
-                                level: "ERROR",
+                                level: 'ERROR',
                                 message: parsed.message,
                             });
                         }
@@ -105,29 +126,64 @@ export class RustCoreBridge {
                     }
                 }
             });
-            child.stderr.on("data", (data) => {
+            child.stderr.on('data', (data) => {
                 const str = data.toString();
                 // Ignore normal compilation progress
-                if (!str.includes("Compiling") && !str.includes("Checking") && !str.includes("Finished")) {
+                if (!str.includes('Compiling') && !str.includes('Checking') && !str.includes('Finished')) {
+                    const trimmed = str.trim();
                     reporter.addLog({
                         timestamp: new Date().toLocaleTimeString(),
-                        level: "DEBUG",
-                        message: str.trim(),
+                        level: 'DEBUG',
+                        message: trimmed,
                     });
+                    // Surface fatal runner errors (e.g. bootstrap failures like a missing APK) immediately —
+                    // previously these only landed in the JSON report's `logs[]`, so a failed run gave no
+                    // visible reason on the terminal.
+                    if (trimmed.startsWith('Error:')) {
+                        console.error(`\x1b[38;2;248;113;113m✖ ${trimmed}\x1b[0m`);
+                    }
                 }
             });
-            child.on("close", (code) => {
-                const result = reporter.generateResult(code === 0 ? "passed" : runStatus, runDuration);
-                if (options.outputJsonPath) {
+            child.on('close', (code) => {
+                let result = reporter.generateResult(code === 0 ? 'passed' : runStatus, runDuration);
+                // Only trust a pre-existing outputJsonPath when it was actually written during THIS run
+                // (mtime at/after runStartedAt) — NOT just when the process exited with code 0. The
+                // native runner writes its own complete report once the pipeline reaches the report
+                // stage, even for a run with failing tests (which still exits non-zero); but if it bails
+                // before ever getting there (missing APK, driver bootstrap error, etc.) a stale file from
+                // an unrelated previous run may still be sitting at this path — trusting it purely based
+                // on exit code would silently report that old run's result instead of the real failure.
+                let isFresh = false;
+                if (options.outputJsonPath && fs.existsSync(options.outputJsonPath)) {
+                    try {
+                        isFresh = fs.statSync(options.outputJsonPath).mtimeMs >= runStartedAt;
+                    }
+                    catch { }
+                }
+                if (isFresh && options.outputJsonPath) {
+                    try {
+                        const raw = fs.readFileSync(options.outputJsonPath, 'utf-8');
+                        const parsed = JSON.parse(raw);
+                        if (parsed.version && parsed.summary) {
+                            result.status = parsed.status || result.status;
+                            result.duration = parsed.duration || result.duration;
+                            result.passedCount = parsed.summary.passed;
+                            result.failedCount = parsed.summary.failed;
+                            return resolve(result);
+                        }
+                    }
+                    catch { }
+                }
+                if (options.outputJsonPath && !isFresh) {
                     const outDir = path.dirname(options.outputJsonPath);
                     if (!fs.existsSync(outDir)) {
                         fs.mkdirSync(outDir, { recursive: true });
                     }
-                    fs.writeFileSync(options.outputJsonPath, JSON.stringify(result, null, 2), "utf-8");
+                    fs.writeFileSync(options.outputJsonPath, JSON.stringify(result, null, 2), 'utf-8');
                 }
                 resolve(result);
             });
-            child.on("error", (err) => {
+            child.on('error', (err) => {
                 reject(err);
             });
         });

package/dist/runner/reporter.d.ts

@@ -1,6 +1,6 @@
 export interface TestLog {
     timestamp: string;
-    level: "INFO" | "SUCCESS" | "WARNING" | "ERROR" | "DEBUG" | string;
+    level: 'INFO' | 'SUCCESS' | 'WARNING' | 'ERROR' | 'DEBUG' | string;
     message: string;
 }
 export interface NetworkResource {
@@ -10,14 +10,44 @@ export interface NetworkResource {
     status: number;
 }
 export interface TestRunResult {
-    status: "passed" | "failed" | "error" | string;
+    status: 'passed' | 'failed' | 'error' | string;
     duration: string;
+    passedCount: number;
+    failedCount: number;
     logs: TestLog[];
     networkResources?: NetworkResource[];
 }
+export interface PendingStep {
+    text: string;
+    duration: number;
+    passed: boolean;
+}
+export interface PendingTestCase {
+    title: string;
+    workerId?: number;
+    steps: PendingStep[];
+    currentStep?: string;
+    errorMsg?: string;
+    startTime: number;
+}
 export declare class Reporter {
     private logs;
     private networkEvents;
+    private pendingTests;
+    private workerToTest;
+    private passedCount;
+    private failedCount;
+    private isInteractive;
+    private lastRenderedLines;
+    private spinnerFrames;
+    private spinnerIndex;
+    private spinnerTimer;
+    constructor();
+    /** Whether this reporter is drawing the live-updating interactive terminal UI (real TTY, not CI/VS Code/test). */
+    isInteractiveMode(): boolean;
+    private clearActiveSlots;
+    private renderActiveSlots;
+    private resolveTestCase;
     addLog(log: TestLog): void;
     addNetwork(res: NetworkResource): void;
     getLogs(): TestLog[];