@piwitests/reporter 0.4.2

package/dist/step-analyzer.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categorizeStep = categorizeStep;
+exports.flattenSteps = flattenSteps;
+exports.collectStepMetrics = collectStepMetrics;
+exports.percentile = percentile;
+exports.computePerformanceSummary = computePerformanceSummary;
+exports.extractTestStepEvents = extractTestStepEvents;
+exports.extractWaitEvents = extractWaitEvents;
+/**
+ * Categorise a Playwright step into `navigation`, `action`, `input`,
+ * `assertion`, `wait`, `api`, `hook`, or `other`.
+ *
+ * Supports two title formats:
+ *  - Legacy api-path titles ("page.goto", "locator.click", "page.waitForTimeout")
+ *  - Modern human-readable titles introduced in newer Playwright versions
+ *    ("Navigate to \"{url}\"", "Click", "Wait for timeout", "Wait for load state").
+ * Hook/fixture/expect steps are detected via Playwright's own `category`.
+ */
+function categorizeStep(title, pwCategory) {
+    if (!title)
+        return 'other';
+    if (pwCategory === 'hook' || pwCategory === 'fixture')
+        return pwCategory;
+    if (pwCategory === 'expect')
+        return 'assertion';
+    const lower = title.toLowerCase();
+    // Waits — modern "Wait for timeout/function/selector/state/navigation/load state/url/event"
+    // and legacy "*.waitFor*" (locator.waitFor, page.waitForLoadState, frame.waitForTimeout, ...).
+    if (lower.startsWith('wait for') ||
+        lower.startsWith('locator.waitfor') ||
+        lower.startsWith('page.waitfor') ||
+        lower.startsWith('frame.waitfor'))
+        return 'wait';
+    // Navigation — modern "Navigate to ...", "Go back", "Go forward", "Reload"; legacy "page.goto" etc.
+    if (lower.startsWith('navigate to') ||
+        lower.startsWith('go back') ||
+        lower.startsWith('go forward') ||
+        lower.startsWith('reload') ||
+        lower.startsWith('page.goto') ||
+        lower.startsWith('page.reload') ||
+        lower.startsWith('page.goback') ||
+        lower.startsWith('page.goforward'))
+        return 'navigation';
+    // Actions — clicks, taps, checks, selects, hovers
+    if (lower.startsWith('click') ||
+        lower.startsWith('double click') ||
+        lower.startsWith('check') ||
+        lower.startsWith('uncheck') ||
+        lower.startsWith('tap') ||
+        lower.startsWith('hover') ||
+        lower.startsWith('select option') ||
+        lower.startsWith('drag') ||
+        lower.startsWith('locator.click') ||
+        lower.startsWith('locator.dblclick') ||
+        lower.startsWith('locator.check') ||
+        lower.startsWith('locator.uncheck') ||
+        lower.startsWith('locator.selectoption') ||
+        lower.startsWith('locator.tap'))
+        return 'action';
+    // Input — fill, type, press, insert text, set input files
+    if (lower.startsWith('fill ') ||
+        lower === 'fill' ||
+        lower.startsWith('type') ||
+        lower.startsWith('press') ||
+        lower.startsWith('insert ') ||
+        lower.startsWith('set input files') ||
+        lower.startsWith('locator.fill') ||
+        lower.startsWith('locator.type') ||
+        lower.startsWith('locator.press') ||
+        lower.startsWith('locator.clear') ||
+        lower.startsWith('locator.setinputfiles'))
+        return 'input';
+    // Assertions — legacy "expect..." titles (modern ones caught via pwCategory above)
+    if (lower.startsWith('expect') || lower.startsWith('locator.expect') || lower.startsWith('page.expect'))
+        return 'assertion';
+    if (lower.startsWith('apirequestcontext') || lower.startsWith('apiresponse'))
+        return 'api';
+    if (lower === 'before hooks' || lower === 'after hooks' || lower.startsWith('fixture:'))
+        return 'hook';
+    return 'other';
+}
+/** Recursively flatten a nested step tree into a flat list. Uses Playwright's built-in category when available. */
+function flattenSteps(steps) {
+    const result = [];
+    for (const step of steps) {
+        result.push({
+            title: step.title,
+            duration: step.duration,
+            category: categorizeStep(step.title, step.category),
+        });
+        if (step.steps?.length > 0)
+            result.push(...flattenSteps(step.steps));
+    }
+    return result;
+}
+/** Collect step metrics (flat steps, slowest step, navigation stats) from a Playwright step array */
+function collectStepMetrics(steps) {
+    const flatSteps = flattenSteps(steps);
+    const totalStepDuration = steps.reduce((sum, s) => sum + (s.duration || 0), 0);
+    let slowestStep = null;
+    for (const s of flatSteps) {
+        if (!slowestStep || s.duration > slowestStep.duration)
+            slowestStep = { title: s.title, duration: s.duration };
+    }
+    const navSteps = flatSteps.filter((s) => s.category === 'navigation');
+    const waitSteps = flatSteps.filter((s) => s.category === 'wait');
+    const waitTotalDuration = waitSteps.reduce((sum, s) => sum + (s.duration || 0), 0);
+    return {
+        steps: flatSteps,
+        totalStepDuration,
+        slowestStep,
+        navigationCount: navSteps.length,
+        navigationTotalDuration: navSteps.reduce((sum, s) => sum + (s.duration || 0), 0),
+        waitTotalDuration,
+        waitCount: waitSteps.length,
+    };
+}
+/** Calculate the p-th percentile from a sorted array of numbers */
+function percentile(sortedArr, p) {
+    if (sortedArr.length === 0)
+        return 0;
+    const index = Math.ceil((p / 100) * sortedArr.length) - 1;
+    return sortedArr[Math.max(0, index)];
+}
+/** Compute run-level performance summary (averages, percentiles, slowest tests) from all test cases */
+function computePerformanceSummary(testCases) {
+    const durations = testCases.filter((tc) => tc.duration != null).map((tc) => tc.duration);
+    if (durations.length === 0)
+        return {};
+    const sorted = [...durations].sort((a, b) => a - b);
+    const sum = durations.reduce((a, b) => a + b, 0);
+    const result = {
+        avgTestDuration: Math.round(sum / durations.length),
+        p50TestDuration: percentile(sorted, 50),
+        p90TestDuration: percentile(sorted, 90),
+        p95TestDuration: percentile(sorted, 95),
+        slowestTests: [...testCases]
+            .filter((tc) => tc.duration != null)
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, 5)
+            .map((tc) => ({ title: tc.title, duration: tc.duration })),
+    };
+    let totalNavDur = 0;
+    let totalNavCount = 0;
+    for (const tc of testCases) {
+        if (tc.performanceMetrics) {
+            totalNavDur += tc.performanceMetrics.navigationTotalDuration || 0;
+            totalNavCount += tc.performanceMetrics.navigationCount || 0;
+        }
+    }
+    result.totalNavigationDuration = totalNavDur;
+    result.avgNavigationDuration = totalNavCount > 0 ? Math.round(totalNavDur / totalNavCount) : 0;
+    let totalWasted = 0;
+    for (const tc of testCases) {
+        if (tc.performanceMetrics) {
+            totalWasted += tc.performanceMetrics.waitTotalDuration || 0;
+        }
+    }
+    result.totalWastedTimeMs = totalWasted;
+    return result;
+}
+/**
+ * Extract hook and fixture step events with absolute timings from a Playwright
+ * step tree. These are used by the WorkersTimeline to render hook segments.
+ *
+ * Returns only top-level hook/fixture steps (beforeEach, afterEach, fixture
+ * setup/teardown) — their sub-steps are included implicitly in their duration.
+ */
+function extractTestStepEvents(steps, _testStartTime) {
+    const events = [];
+    for (const step of steps) {
+        const cat = categorizeStep(step.title, step.category);
+        if (cat !== 'hook' && cat !== 'fixture')
+            continue;
+        if (!step.startTime)
+            continue;
+        const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : step.startTime;
+        events.push({
+            title: step.title,
+            category: cat,
+            startedAt,
+            duration: step.duration || 0,
+            status: step.error ? 'failed' : 'passed',
+            location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : null,
+        });
+    }
+    return events;
+}
+/**
+ * Recursively extract wait-category steps from the Playwright step tree
+ * with absolute timings. These are rendered as semi-transparent amber bars
+ * on WorkersTimeline to visualize wasted time.
+ */
+function extractWaitEvents(steps, insideWait = false) {
+    const events = [];
+    for (const step of steps) {
+        const cat = categorizeStep(step.title, step.category);
+        const isWait = cat === 'wait';
+        if (isWait && !insideWait && step.startTime) {
+            const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : step.startTime;
+            events.push({
+                title: step.title,
+                category: 'wait',
+                startedAt,
+                duration: step.duration || 0,
+                status: 'wasted',
+                location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : null,
+            });
+        }
+        if (step.steps?.length > 0) {
+            events.push(...extractWaitEvents(step.steps, insideWait || isWait));
+        }
+    }
+    return events;
+}

package/dist/stream-buffer.d.ts

@@ -0,0 +1,17 @@
+import type { StreamEvent } from './types.js';
+/**
+ * Persistent JSONL buffer on disk.  Events are appended to a temp file so they
+ * survive a crash and can be replayed when the reporter restarts.
+ */
+export declare class StreamBuffer {
+    private filePath;
+    constructor(projectName: string);
+    /** Append one or more events to the on-disk buffer */
+    append(events: StreamEvent[]): void;
+    /** Load all buffered events from disk, clearing the file */
+    load(): StreamEvent[];
+    /** Delete the buffer file from disk */
+    clear(): void;
+    /** Remove the buffer file if it is older than `maxAgeMs` (default 2 hours). Used on startup to discard orphaned data. */
+    clearStale(maxAgeMs?: number): void;
+}

package/dist/stream-buffer.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamBuffer = void 0;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const helpers_js_1 = require("./helpers.js");
+/**
+ * Persistent JSONL buffer on disk.  Events are appended to a temp file so they
+ * survive a crash and can be replayed when the reporter restarts.
+ */
+class StreamBuffer {
+    constructor(projectName) {
+        this.filePath = path.join(os.tmpdir(), `piwi-dashboard-stream-${(0, helpers_js_1.hashForProject)(projectName)}.jsonl`);
+    }
+    /** Append one or more events to the on-disk buffer */
+    append(events) {
+        if (events.length === 0)
+            return;
+        try {
+            const lines = events.map((e) => JSON.stringify(e) + '\n').join('');
+            fs.appendFileSync(this.filePath, lines, 'utf8');
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    /** Load all buffered events from disk, clearing the file */
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const content = fs.readFileSync(this.filePath, 'utf8');
+                return content
+                    .split('\n')
+                    .filter(Boolean)
+                    .map((line) => JSON.parse(line));
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+        return [];
+    }
+    /** Delete the buffer file from disk */
+    clear() {
+        try {
+            if (fs.existsSync(this.filePath))
+                fs.unlinkSync(this.filePath);
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    /** Remove the buffer file if it is older than `maxAgeMs` (default 2 hours). Used on startup to discard orphaned data. */
+    clearStale(maxAgeMs = 7200000) {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const stats = fs.statSync(this.filePath);
+                if (Date.now() - stats.mtimeMs > maxAgeMs) {
+                    fs.unlinkSync(this.filePath);
+                }
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+}
+exports.StreamBuffer = StreamBuffer;

package/dist/stream-manager.d.ts

@@ -0,0 +1,74 @@
+import type { PiwiDashboardOptions, ShardInfo } from './config.js';
+import { HttpClient } from './http-client.js';
+import { StreamBuffer } from './stream-buffer.js';
+import { CrashRecovery } from './crash-recovery.js';
+import { Uploader } from './uploader.js';
+import { FileHandler } from './file-handler.js';
+import { Logger } from './logger.js';
+import type { CollectedTestCase, StreamEvent, FilterDetails } from './types.js';
+/**
+ * Manages the streaming protocol: queues events (begin / complete), flushes
+ * them in batches, schedules retries on failure, and handles per-test-case
+ * live file uploads.
+ */
+export declare class StreamManager {
+    private readonly httpClient;
+    private readonly streamBuffer;
+    private readonly recovery;
+    private readonly uploader;
+    private readonly fileHandler;
+    private readonly options;
+    private readonly logger;
+    private pendingEvents;
+    private pendingBeginEvents;
+    private flushTimer;
+    private flushPromises;
+    private liveUploadPromises;
+    private readonly limitLiveUpload;
+    private retryCount;
+    private retryTimer;
+    private readonly maxRetryDelay;
+    /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
+    private readonly uploadedCaseFiles;
+    private _enabled;
+    private _runId;
+    private _token;
+    private _auth;
+    private _startPromise;
+    /** Whether the streaming session is active */
+    get enabled(): boolean;
+    /** Server-assigned run ID (`null` until the stream opens) */
+    get runId(): number | null;
+    /** Stream authentication token (`null` until the stream opens) */
+    get token(): string | null;
+    /** Resolved auth string (API key or session cookie) used in stream requests */
+    get auth(): string | null;
+    /** Promise that resolves when the stream has been fully initialised */
+    get startPromise(): Promise<void> | null;
+    /**
+     * @param httpClient  HTTP client for server communication.
+     * @param streamBuffer On-disk buffer for crash-safe event persistence.
+     * @param recovery    Crash-recovery handler for uploading stale payloads on startup.
+     * @param uploader    Uploader for per-test-case file uploads.
+     * @param fileHandler File-discovery helper for finding traces and attachments.
+     * @param options     Piwi Dashboard reporter options.
+     * @param logger      Prefixed logger.
+     */
+    constructor(httpClient: HttpClient, streamBuffer: StreamBuffer, recovery: CrashRecovery, uploader: Uploader, fileHandler: FileHandler, options: PiwiDashboardOptions, logger?: Logger);
+    /** Begin the streaming session after `onBegin` fires. Non-blocking — the actual handshake runs asynchronously. */
+    start(startTime: string, metadata: Record<string, any>, instanceId: string, playwrightVersion?: string | null, shardInfo?: ShardInfo | null, isFullRun?: boolean, filterDetails?: FilterDetails | null): void;
+    private _doStart;
+    /** Queue a test-case `begin` event. Held in a pre-start buffer if the stream is not yet open, then prepended so it arrives before the matching `complete` event. */
+    queueBeginEvent(event: StreamEvent): void;
+    /** Queue a test-case event. Triggers an immediate flush when the batch size is reached, otherwise schedules a timer-based flush. */
+    queueEvent(event: StreamEvent): void;
+    /** 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;
+    /** 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. */
+    scheduleLiveUpload(tc: CollectedTestCase): void;
+    /** Wait for all live uploads to settle, then upload files for any test cases that weren't uploaded live */
+    uploadRemaining(testCases: CollectedTestCase[]): Promise<void>;
+}