@piwitests/reporter 0.4.3 → 0.5.0

package/dist/reporter.js

@@ -45,10 +45,35 @@ const metadata_collector_js_1 = require("./metadata-collector.js");
 const stream_manager_js_1 = require("./stream-manager.js");
 const step_analyzer_js_1 = require("./step-analyzer.js");
 const helpers_js_1 = require("./helpers.js");
+const config_wrapper_js_1 = require("./config-wrapper.js");
 const serializer_js_1 = require("./serializer.js");
 const skip_classify_js_1 = require("./skip-classify.js");
 const run_submitter_js_1 = require("./run-submitter.js");
 const logger_js_1 = require("./logger.js");
+/**
+ * Build the stored error text for a test result.
+ *
+ * Playwright's `error.message` carries the failure message and call log but no
+ * stack frames — those live on `error.stack`/`error.location`. The server's
+ * locator-healing lookup needs the failing call site to find the pre-captured
+ * snapshot for that locator, so when the message has no `at …` frame we append
+ * a synthetic one from `error.location`, relativized to the cwd so it matches
+ * the format the fixture records at capture time. The frame is appended after
+ * the message, where `extractMessageHead` already trims it off before
+ * fingerprinting — so failure clustering is unaffected.
+ */
+function buildErrorText(result) {
+    const err = result.error;
+    if (!err)
+        return null;
+    let text = err.message ?? '';
+    const loc = err.location;
+    if (loc?.file && !/\n\s+at\s/.test(text)) {
+        const rel = path.relative(process.cwd(), loc.file).split(path.sep).join('/');
+        text += `\n    at ${rel}:${loc.line}:${loc.column}`;
+    }
+    return text;
+}
 /**
  * Piwi Dashboard Playwright reporter.
  *
@@ -81,7 +106,7 @@ class PiwiDashboardReporter {
         /** Track suite-level setup steps (beforeAll/afterAll) not tied to any test */
         this.setupSteps = [];
         this.options = (0, config_js_1.resolveOptions)(rawOptions);
-        this.enabled = !!this.options.serverUrl;
+        this.enabled = this.options.enabled !== false && !!this.options.serverUrl;
         this.runLabel = this.options.runLabel || (0, helpers_js_1.detectCiRunLabel)();
         this.instanceId = (0, helpers_js_1.computeInstanceId)(this.options.projectName, this.runLabel);
         const logger = new logger_js_1.Logger(this.options.verbose ?? false);
@@ -177,9 +202,11 @@ class PiwiDashboardReporter {
     }
     /** Playwright reporter hook: called when a step (including hook/fixture) ends */
     onStepEnd(test, _result, step) {
+        const cat = step.category;
+        if (cat === 'pw:api')
+            return; // not surfaced as stream events; locator locations are captured in the fixture
         if (!this.enabled || !this.streamManager?.enabled)
             return;
-        const cat = step.category;
         if (cat !== 'hook' && cat !== 'fixture')
             return;
         const workerIndex = (0, helpers_js_1.workerIndexOf)(_result);
@@ -223,7 +250,7 @@ class PiwiDashboardReporter {
             location: `${relativeFilePath}:${test.location.line}:${test.location.column}`,
             status,
             duration: result.duration,
-            error: result.error ? result.error.message : null,
+            error: buildErrorText(result),
             retries: result.retry,
             workerIndex: (0, helpers_js_1.workerIndexOf)(result),
             shardIndex: this.shardInfo?.current ?? null,
@@ -249,6 +276,20 @@ class PiwiDashboardReporter {
         }
         if (this.options.collectPerformanceMetrics && result.attachments) {
             this.fileHandler.parsePerformanceAttachments(testCase, result.attachments);
+            // Locator snapshots arrive pre-stamped with their call-site `location`
+            // (captured in the fixture at action call time). No index correlation
+            // with pw:api steps — that was unreliable across workers/concurrent calls.
+            const locatorAttachment = this.options.captureLocators !== false
+                ? result.attachments.find((a) => a.name === 'piwi-dashboard-locators')
+                : undefined;
+            if (locatorAttachment?.body) {
+                try {
+                    testCase.locatorSnapshots = JSON.parse(locatorAttachment.body.toString());
+                }
+                catch {
+                    /* ignore parse errors */
+                }
+            }
         }
         switch (status) {
             case 'passed':
@@ -338,4 +379,5 @@ class PiwiDashboardReporter {
     }
 }
 exports.PiwiDashboardReporter = PiwiDashboardReporter;
+PiwiDashboardReporter.wrapConfig = config_wrapper_js_1.wrapConfig;
 PiwiDashboardReporter.createGlobalSetup = helpers_js_1.createGlobalSetup;

package/dist/run-submitter.js

@@ -87,6 +87,7 @@ class RunSubmitter {
             totalTests: run.totalTests,
             passedTests: run.passedTests,
             failedTests: run.failedTests,
+            timedOutTests: run.timedOutTests,
             skippedTests: run.skippedTests,
             didNotRunTests: run.didNotRunTests,
             environment: run.options.environment,
@@ -114,6 +115,7 @@ class RunSubmitter {
                 totalTests: run.totalTests,
                 passedTests: run.passedTests,
                 failedTests: run.failedTests,
+                timedOutTests: run.timedOutTests,
                 skippedTests: run.skippedTests,
                 didNotRunTests: run.didNotRunTests,
                 flakyTests,

package/dist/serializer.js

@@ -64,6 +64,7 @@ function toWireTestCase(tc) {
         suitePath: rest.suitePath ?? null,
         suiteConfig: rest.suiteConfig ?? null,
         testAnnotations: rest.testAnnotations ?? null,
+        locatorSnapshots: rest.locatorSnapshots || null,
     };
 }
 /**
@@ -85,6 +86,7 @@ function serializeRun(payload, opts) {
         totalTests: payload.totalTests,
         passedTests: payload.passedTests,
         failedTests: payload.failedTests,
+        timedOutTests: payload.timedOutTests ?? 0,
         skippedTests: payload.skippedTests,
         didNotRunTests: payload.didNotRunTests ?? 0,
         environment: payload.environment ?? null,

package/dist/stream-manager.d.ts

@@ -28,6 +28,16 @@ export declare class StreamManager {
     private retryCount;
     private retryTimer;
     private readonly maxRetryDelay;
+    /**
+     * Idle heartbeat: while the run is open but no events are flowing (e.g. a single
+     * long test, or `beforeAll` setup), a periodic ping keeps the server's activity
+     * timestamp fresh so the stale-run reaper can tell a live run from a crashed one.
+     * The interval must stay well below the server's stale timeout.
+     */
+    private heartbeatTimer;
+    private heartbeatStopped;
+    private lastActivityAt;
+    private readonly heartbeatInterval;
     /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
     private readonly uploadedCaseFiles;
     private _enabled;
@@ -65,6 +75,10 @@ export declare class StreamManager {
     /** Flush all pending events to the server. Returns a promise that resolves to `true` on success or `false` on failure (events are re-queued for retry). */
     flush(): Promise<boolean> | null;
     private scheduleRetry;
+    private scheduleHeartbeat;
+    private sendHeartbeat;
+    /** Stop the idle heartbeat permanently (called when the run is wrapping up). */
+    private stopHeartbeat;
     /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
     drain(): Promise<void>;
     /** Schedule a live upload of trace and attachment files for a test case. Skips cases with no files. Concurrency is limited to 2 simultaneous uploads. */

package/dist/stream-manager.js

@@ -89,6 +89,16 @@ class StreamManager {
         this.retryCount = 0;
         this.retryTimer = null;
         this.maxRetryDelay = 30000;
+        /**
+         * Idle heartbeat: while the run is open but no events are flowing (e.g. a single
+         * long test, or `beforeAll` setup), a periodic ping keeps the server's activity
+         * timestamp fresh so the stale-run reaper can tell a live run from a crashed one.
+         * The interval must stay well below the server's stale timeout.
+         */
+        this.heartbeatTimer = null;
+        this.heartbeatStopped = false;
+        this.lastActivityAt = 0;
+        this.heartbeatInterval = 15000;
         /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
         this.uploadedCaseFiles = new WeakSet();
         this._enabled = false;
@@ -165,6 +175,8 @@ class StreamManager {
                 this._token = response.streamToken;
                 this._enabled = true;
                 this.logger.info(`Streaming enabled. Run ID: ${response.runId}`);
+                this.lastActivityAt = Date.now();
+                this.scheduleHeartbeat();
                 if (this.pendingBeginEvents.length > 0) {
                     this.pendingEvents = [...this.pendingBeginEvents, ...this.pendingEvents];
                     this.pendingBeginEvents = [];
@@ -213,6 +225,7 @@ class StreamManager {
             .postJSON(`/api/test-runs/${this._runId}/events`, { streamToken: this._token, testCases: events }, this._auth)
             .then(() => {
             this.retryCount = 0;
+            this.lastActivityAt = Date.now();
             return true;
         }, () => {
             this.pendingEvents = events.concat(this.pendingEvents);
@@ -239,8 +252,46 @@ class StreamManager {
                 this.flush();
         }, delay);
     }
+    // Schedule the next idle heartbeat. Self-rescheduling; cleared by stopHeartbeat.
+    scheduleHeartbeat() {
+        if (this.heartbeatStopped || this.heartbeatTimer)
+            return;
+        this.heartbeatTimer = setTimeout(() => {
+            this.heartbeatTimer = null;
+            void this.sendHeartbeat();
+        }, this.heartbeatInterval);
+    }
+    // Ping the server only when the run has actually been idle. Real event traffic
+    // already bumps the server's activity timestamp, so a recent flush (or pending
+    // events about to flush) makes the ping redundant — skip it and reschedule.
+    async sendHeartbeat() {
+        if (this.heartbeatStopped || !this._enabled || !this._runId || !this._token)
+            return;
+        const idleFor = Date.now() - this.lastActivityAt;
+        if (idleFor < this.heartbeatInterval || this.pendingEvents.length > 0) {
+            this.scheduleHeartbeat();
+            return;
+        }
+        try {
+            await this.httpClient.postJSON(`/api/test-runs/${this._runId}/heartbeat`, { streamToken: this._token }, this._auth);
+            this.lastActivityAt = Date.now();
+        }
+        catch (error) {
+            this.logger.debug(`Heartbeat failed: ${error.message}`);
+        }
+        this.scheduleHeartbeat();
+    }
+    /** Stop the idle heartbeat permanently (called when the run is wrapping up). */
+    stopHeartbeat() {
+        this.heartbeatStopped = true;
+        if (this.heartbeatTimer) {
+            clearTimeout(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
     /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
     async drain() {
+        this.stopHeartbeat();
         if (!this._enabled) {
             this.pendingEvents = [];
             this.flushPromises = [];

package/dist/types.d.ts

@@ -142,6 +142,8 @@ export interface CollectedTestCase {
     consoleLogs?: unknown;
     /** Parsed from `piwi-dashboard-aria-snapshot` attachment. */
     ariaSnapshot?: string;
+    /** Parsed from `piwi-dashboard-locators` attachment. */
+    locatorSnapshots?: import('./locator-healing.js').LocatorSnapshot[];
 }
 /**
  * The per-case wire shape that `toWireTestCase` produces and the server
@@ -176,6 +178,8 @@ export interface WireTestCase {
     /** Step-event discriminant (only for `step-begin`/`step-end` events). */
     stepCategory?: string | null;
     parentTitle?: string | null;
+    /** Per-element locator snapshots with ranked alternatives (transient — not stored per-run). */
+    locatorSnapshots?: unknown;
 }
 export interface BeginStreamEvent {
     type: 'begin';
@@ -211,6 +215,7 @@ export interface CompleteStreamEvent {
     consoleLogs?: unknown;
     ariaSnapshot?: unknown;
     testSource?: string | null;
+    locatorSnapshots?: unknown;
 }
 export interface StepBeginStreamEvent {
     type: 'step-begin';

package/dist/uploader.d.ts

@@ -17,6 +17,7 @@ export interface RunPayload {
     totalTests: number;
     passedTests: number;
     failedTests: number;
+    timedOutTests?: number;
     skippedTests: number;
     /** Tests that never executed (cut short by `maxFailures` or a serial-group failure) */
     didNotRunTests?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piwitests/reporter",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Playwright reporter for sending test results to Piwi Dashboard",
   "url": "https://github.com/PiwiTests/platform",
   "homepage": "https://piwitests.github.io",