@piwitests/reporter 0.4.2

package/dist/crash-recovery.js

@@ -0,0 +1,105 @@
+"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.CrashRecovery = void 0;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const helpers_js_1 = require("./helpers.js");
+const logger_js_1 = require("./logger.js");
+/**
+ * Persists a test-run payload to disk when all upload strategies fail, so the
+ * data can be retried on the next run.
+ */
+class CrashRecovery {
+    /**
+     * @param projectName Used to derive the temp-file name so recovery data is project-scoped.
+     * @param logger      Prefixed logger.
+     */
+    constructor(projectName, logger = new logger_js_1.Logger()) {
+        this.logger = logger;
+        this.filePath = path.join(os.tmpdir(), `piwi-dashboard-recovery-${(0, helpers_js_1.hashForProject)(projectName)}.json`);
+    }
+    /** Serialise the payload to a temp file for later retry */
+    save(data) {
+        try {
+            fs.writeFileSync(this.filePath, JSON.stringify(data), 'utf8');
+            this.logger.info('Saved recovery data for later upload');
+        }
+        catch (error) {
+            this.logger.error(`Failed to save recovery data: ${error.message}`);
+        }
+    }
+    /** Read the saved payload from disk, or return `null` if none exists */
+    load() {
+        try {
+            if (fs.existsSync(this.filePath))
+                return JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
+        }
+        catch {
+            // Non-fatal
+        }
+        return null;
+    }
+    /** Delete the recovery file from disk */
+    clear() {
+        try {
+            if (fs.existsSync(this.filePath))
+                fs.unlinkSync(this.filePath);
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    /** Attempt to submit a previously saved payload. Clears the recovery file on success. */
+    async tryUpload(httpClient, auth) {
+        const data = this.load();
+        if (!data)
+            return;
+        this.logger.info('Found saved test data from a previous run, uploading...');
+        // Strip instanceId so /submit doesn't cancel the current run (which shares
+        // the same instanceId for the same project + hostname combination).
+        delete data.instanceId;
+        try {
+            await httpClient.postJSON('/api/test-runs/submit', data, auth);
+            this.logger.info('Successfully uploaded saved test data');
+            this.clear();
+        }
+        catch (error) {
+            this.logger.warn(`Could not upload saved test data: ${error.message}`);
+        }
+    }
+}
+exports.CrashRecovery = CrashRecovery;

package/dist/file-handler.d.ts

@@ -0,0 +1,38 @@
+import { Logger } from './logger.js';
+import type { CollectedTestCase, RawAttachment, TraceHashInfo } from './types.js';
+/**
+ * File-system helpers for discovering report directories, trace files, and
+ * test attachments, as well as compressing report directories and computing
+ * trace-file hashes for deduplication.
+ */
+export declare class FileHandler {
+    private readonly logger;
+    constructor(logger?: Logger);
+    /** Locate a Playwright HTML report directory containing `index.html`. Optionally override the search path. */
+    findHTMLReportDirectory(customDir?: string): string | null;
+    /** Check if `dir` exists and is a directory; also checks `path.join(process.cwd(), dir)` */
+    findReportDirectory(dir: string): string | null;
+    /** Gzip-compress an entire report directory into a single buffer. Returns `null` on failure. */
+    compressReportDirectory(reportDir: string): Promise<Buffer | null>;
+    /** Return resolved paths for all trace attachments on a test case */
+    findTraceFiles(testCase: CollectedTestCase): string[];
+    /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-dashboard-*` attachments. */
+    findAllAttachments(testCase: CollectedTestCase): Array<{
+        name: string;
+        path: string;
+        contentType: string;
+        originalName: string;
+    }>;
+    /** Mapping of well-known report type names to their default output directories */
+    getDefaultReportDirs(): Record<string, string>;
+    /** Parse Piwi-internal attachment bodies (`piwi-dashboard-network`, `-web-vitals`, `-console`, `-aria-snapshot`) into structured fields on the test case */
+    parsePerformanceAttachments(testCase: CollectedTestCase, attachments: RawAttachment[]): void;
+    /** Compute SHA-256 hash and size for a single test case's trace file. Returns `null` when the case has no trace on disk. */
+    computeSingleTraceHash(testCase: CollectedTestCase): Promise<TraceHashInfo | null>;
+    /** Ask the server which trace hashes it already has, returning the set of hashes that are missing */
+    checkMissingTraces(httpClient: {
+        postJSON(path: string, payload: any, auth?: string | null): Promise<any>;
+    }, projectName: string, traceHashMap: Map<number, {
+        hash: string;
+    }>, auth: string | null): Promise<Set<string>>;
+}

package/dist/file-handler.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandler = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const compression_js_1 = require("./compression.js");
+const logger_js_1 = require("./logger.js");
+/**
+ * File-system helpers for discovering report directories, trace files, and
+ * test attachments, as well as compressing report directories and computing
+ * trace-file hashes for deduplication.
+ */
+class FileHandler {
+    constructor(logger = new logger_js_1.Logger()) {
+        this.logger = logger;
+    }
+    /** Locate a Playwright HTML report directory containing `index.html`. Optionally override the search path. */
+    findHTMLReportDirectory(customDir) {
+        const possibleDirs = customDir
+            ? [customDir, path_1.default.join(process.cwd(), customDir)]
+            : ['playwright-report', './playwright-report', path_1.default.join(process.cwd(), 'playwright-report')];
+        for (const reportDir of possibleDirs) {
+            if (fs_1.default.existsSync(reportDir) && fs_1.default.statSync(reportDir).isDirectory()) {
+                if (fs_1.default.existsSync(path_1.default.join(reportDir, 'index.html')))
+                    return reportDir;
+            }
+        }
+        return null;
+    }
+    /** Check if `dir` exists and is a directory; also checks `path.join(process.cwd(), dir)` */
+    findReportDirectory(dir) {
+        const candidates = [dir, path_1.default.join(process.cwd(), dir)];
+        for (const candidate of candidates) {
+            if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isDirectory())
+                return candidate;
+        }
+        return null;
+    }
+    /** Gzip-compress an entire report directory into a single buffer. Returns `null` on failure. */
+    async compressReportDirectory(reportDir) {
+        try {
+            return (await (0, compression_js_1.compressDirectory)(reportDir)) || null;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to compress report directory ${reportDir}: ${error.message}`);
+            return null;
+        }
+    }
+    /** Return resolved paths for all trace attachments on a test case */
+    findTraceFiles(testCase) {
+        const set = new Set();
+        if (testCase.attachments) {
+            for (const a of testCase.attachments) {
+                if (a.name === 'trace' && a.path)
+                    set.add(path_1.default.resolve(a.path));
+            }
+        }
+        return Array.from(set);
+    }
+    /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-dashboard-*` attachments. */
+    findAllAttachments(testCase) {
+        const result = [];
+        if (testCase.attachments) {
+            for (const a of testCase.attachments) {
+                if (a.name === 'trace')
+                    continue;
+                if (a.name?.startsWith('piwi-dashboard-'))
+                    continue;
+                if (a.path && fs_1.default.existsSync(a.path)) {
+                    result.push({
+                        name: a.name || 'attachment',
+                        path: path_1.default.resolve(a.path),
+                        contentType: a.contentType || 'application/octet-stream',
+                        originalName: path_1.default.basename(a.path),
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    /** Mapping of well-known report type names to their default output directories */
+    getDefaultReportDirs() {
+        return {
+            html: 'playwright-report',
+            monocart: 'monocart-report',
+            allure: 'allure-report',
+            blob: 'blob-report',
+        };
+    }
+    /** Parse Piwi-internal attachment bodies (`piwi-dashboard-network`, `-web-vitals`, `-console`, `-aria-snapshot`) into structured fields on the test case */
+    parsePerformanceAttachments(testCase, attachments) {
+        const find = (name) => attachments.find((a) => a.name === name);
+        const net = find('piwi-dashboard-network');
+        if (net?.body) {
+            try {
+                testCase.networkRequests = JSON.parse(net.body.toString());
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const vitals = find('piwi-dashboard-web-vitals');
+        if (vitals?.body) {
+            try {
+                testCase.webVitals = JSON.parse(vitals.body.toString());
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const consoleLog = find('piwi-dashboard-console');
+        if (consoleLog?.body) {
+            try {
+                testCase.consoleLogs = JSON.parse(consoleLog.body.toString());
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const aria = find('piwi-dashboard-aria-snapshot');
+        if (aria?.body)
+            testCase.ariaSnapshot = aria.body.toString();
+    }
+    /** Compute SHA-256 hash and size for a single test case's trace file. Returns `null` when the case has no trace on disk. */
+    async computeSingleTraceHash(testCase) {
+        const tracePaths = this.findTraceFiles(testCase);
+        let lastPath = null;
+        for (const tp of tracePaths) {
+            if (fs_1.default.existsSync(tp))
+                lastPath = tp;
+        }
+        if (!lastPath)
+            return null;
+        const hash = crypto_1.default.createHash('sha256');
+        await new Promise((resolve, reject) => {
+            fs_1.default.createReadStream(lastPath)
+                .on('data', (chunk) => hash.update(chunk))
+                .on('end', resolve)
+                .on('error', reject);
+        });
+        return {
+            tracePath: lastPath,
+            hash: hash.digest('hex'),
+            size: fs_1.default.statSync(lastPath).size,
+        };
+    }
+    /** Ask the server which trace hashes it already has, returning the set of hashes that are missing */
+    async checkMissingTraces(httpClient, projectName, traceHashMap, auth) {
+        if (traceHashMap.size === 0)
+            return new Set();
+        const hashes = [...traceHashMap.values()].map((h) => h.hash);
+        try {
+            const response = await httpClient.postJSON('/api/traces/check', { projectName, hashes }, auth);
+            const missing = Array.isArray(response.missing) ? response.missing : hashes;
+            return new Set(missing);
+        }
+        catch {
+            return new Set(hashes);
+        }
+    }
+}
+exports.FileHandler = FileHandler;

package/dist/fixtures.d.ts

@@ -0,0 +1,25 @@
+import type { Fixtures } from '@playwright/test';
+/**
+ * Playwright fixtures that collect network requests, console entries,
+ * web vitals, and ARIA snapshots during a test.
+ *
+ * Attaches collected data as `piwi-dashboard-*` test-info attachments
+ * which the Piwi Dashboard reporter parses on `onTestEnd`.
+ */
+export declare const dashboardFixtures: Fixtures;
+/**
+ * Extend a Playwright `test` object with Piwi Dashboard fixtures.
+ *
+ * Use this instead of importing `@playwright/test` directly from this package
+ * to avoid the "Requiring @playwright/test second time" error caused by
+ * duplicate module resolution.
+ *
+ * @example
+ * ```ts
+ * import { test as base } from '@playwright/test';
+ * import { extendDashboardFixtures } from '@piwitests/reporter/fixtures';
+ *
+ * export const test = extendDashboardFixtures(base);
+ * ```
+ */
+export declare function extendDashboardFixtures<T>(test: T): T;

package/dist/fixtures.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardFixtures = void 0;
+exports.extendDashboardFixtures = extendDashboardFixtures;
+const zlib_1 = require("zlib");
+/**
+ * Playwright fixtures that collect network requests, console entries,
+ * web vitals, and ARIA snapshots during a test.
+ *
+ * Attaches collected data as `piwi-dashboard-*` test-info attachments
+ * which the Piwi Dashboard reporter parses on `onTestEnd`.
+ */
+exports.dashboardFixtures = {
+    page: async ({ page }, use, testInfo) => {
+        const networkRequests = [];
+        const consoleEntries = [];
+        const pendingHandlers = [];
+        page.on('console', (msg) => {
+            const type = msg.type();
+            if (['warning', 'error', 'assert'].includes(type)) {
+                consoleEntries.push({
+                    type,
+                    text: msg.text(),
+                    timestamp: Date.now(),
+                    location: msg.location()
+                        ? `${msg.location().url}:${msg.location().lineNumber}:${msg.location().columnNumber}`
+                        : null,
+                });
+            }
+        });
+        page.on('requestfinished', (request) => {
+            const p = (async () => {
+                try {
+                    const url = request.url();
+                    if (url.startsWith('data:') || url.startsWith('blob:'))
+                        return;
+                    const timing = request.timing();
+                    const response = await request.response();
+                    const resourceType = request.resourceType();
+                    // Only keep API/document requests; skip static assets (scripts, styles, fonts, images, media)
+                    if (!['fetch', 'xhr', 'document', 'other'].includes(resourceType))
+                        return;
+                    const entry = {
+                        method: request.method(),
+                        url,
+                        status: response ? response.status() : 0,
+                        duration: timing.responseEnd > 0 ? Math.round(timing.responseEnd - timing.requestStart) : 0,
+                        startTime: timing.startTime,
+                        resourceType,
+                    };
+                    if (response) {
+                        const logHeader = response.headers()['x-piwi-logs'];
+                        if (logHeader) {
+                            try {
+                                entry.serverLogs = JSON.parse((0, zlib_1.gunzipSync)(Buffer.from(logHeader, 'base64')).toString('utf-8'));
+                            }
+                            catch {
+                                /* ignore malformed header */
+                            }
+                        }
+                    }
+                    networkRequests.push(entry);
+                }
+                catch {
+                    /* ignore */
+                }
+            })();
+            pendingHandlers.push(p);
+        });
+        await use(page);
+        // Wait for all in-flight requestfinished handlers before snapshotting
+        // networkRequests — the last request (often the one that failed the test)
+        // races with fixture teardown and its serverLogs would otherwise be lost.
+        await Promise.allSettled(pendingHandlers);
+        if (testInfo.status !== 'passed' && testInfo.status !== 'skipped') {
+            try {
+                const snapshot = await page.locator(':root').ariaSnapshot();
+                if (snapshot) {
+                    await testInfo.attach('piwi-dashboard-aria-snapshot', {
+                        contentType: 'text/plain',
+                        body: snapshot,
+                    });
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (consoleEntries.length > 0) {
+            await testInfo.attach('piwi-dashboard-console', {
+                contentType: 'application/json',
+                body: Buffer.from(JSON.stringify(consoleEntries)),
+            });
+        }
+        if (networkRequests.length > 0) {
+            await testInfo.attach('piwi-dashboard-network', {
+                contentType: 'application/json',
+                body: Buffer.from(JSON.stringify(networkRequests)),
+            });
+        }
+        try {
+            const webVitals = await page.evaluate(() => {
+                const navEntries = performance.getEntriesByType('navigation');
+                const paintEntries = performance.getEntriesByType('paint');
+                const nav = navEntries[0];
+                const navigation = nav
+                    ? {
+                        url: nav.name,
+                        ttfb: Math.round(nav.responseStart - nav.fetchStart),
+                        domInteractive: Math.round(nav.domInteractive - nav.fetchStart),
+                        domContentLoaded: Math.round(nav.domContentLoadedEventEnd - nav.fetchStart),
+                        loadComplete: Math.round(nav.loadEventEnd - nav.fetchStart),
+                        transferSize: nav.transferSize || 0,
+                        encodedBodySize: nav.encodedBodySize || 0,
+                        decodedBodySize: nav.decodedBodySize || 0,
+                    }
+                    : null;
+                const paint = {};
+                for (const entry of paintEntries) {
+                    const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+                    paint[key] = Math.round(entry.startTime);
+                }
+                if (!navigation && Object.keys(paint).length === 0)
+                    return null;
+                return { navigation, paint };
+            });
+            if (webVitals) {
+                await testInfo.attach('piwi-dashboard-web-vitals', {
+                    contentType: 'application/json',
+                    body: Buffer.from(JSON.stringify(webVitals)),
+                });
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    },
+};
+/**
+ * Extend a Playwright `test` object with Piwi Dashboard fixtures.
+ *
+ * Use this instead of importing `@playwright/test` directly from this package
+ * to avoid the "Requiring @playwright/test second time" error caused by
+ * duplicate module resolution.
+ *
+ * @example
+ * ```ts
+ * import { test as base } from '@playwright/test';
+ * import { extendDashboardFixtures } from '@piwitests/reporter/fixtures';
+ *
+ * export const test = extendDashboardFixtures(base);
+ * ```
+ */
+function extendDashboardFixtures(test) {
+    return test.extend(exports.dashboardFixtures);
+}

package/dist/global-setup-module.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (config: any) => Promise<any>;
+export default _default;

package/dist/global-setup-module.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_js_1 = require("./helpers.js");
+exports.default = (0, helpers_js_1.createGlobalSetup)();

package/dist/helpers.d.ts

@@ -0,0 +1,44 @@
+import type { PiwiDashboardOptions } from './config.js';
+/** Produce a deterministic short SHA-1 hex hash for a project name (used in temp file names) */
+export declare function hashForProject(projectName: string): string;
+/**
+ * Extract a worker index from a Playwright `TestResult`, falling back to
+ * `parallelIndex` when `workerIndex` is absent. Returns `null` when neither is
+ * set. Localizes the `as any` reach into Playwright's result object so the
+ * cast lives in exactly one place.
+ */
+export declare function workerIndexOf(result: any): number | null;
+export declare function detectCliFileFilters(argv?: string[]): string[];
+/** Return the temp-file path used to exchange setup info between globalSetup and the reporter instance */
+export declare function getSetupFilePath(projectName: string): string;
+/** Derive a unique instance identifier by hashing hostname + projectName (or runLabel + projectName when sharding) */
+export declare function computeInstanceId(projectName: string, runLabel?: string | null): string;
+/** Detect a stable CI run label from well-known environment variables. Returns null outside CI. */
+export declare function detectCiRunLabel(): string | null;
+/** Information saved by the global setup for the reporter instance to consume */
+export interface SetupInfo {
+    /** Server-assigned run ID */
+    runId: number;
+    /** One-time token used to authenticate the /begin call */
+    setupToken: string;
+    /** Project name this run belongs to */
+    projectName: string;
+}
+/** Read and delete the setup info file for the given project. Returns `null` when no file exists. */
+export declare function readSetupInfo(projectName: string): SetupInfo | null;
+/** Read a snippet of source code surrounding the given line, returning a formatted string with line numbers. Returns `null` on error. */
+export declare function readSourceSnippet(file: string, line: number, context: number): string | null;
+/** Create a concurrency limiter that ensures at most `maxConcurrent` async operations run simultaneously */
+export declare function createLimiter(maxConcurrent: number): <T>(fn: () => Promise<T>) => Promise<T>;
+/**
+ * Create a Playwright `globalSetup` function that registers a test run on the
+ * Piwi Dashboard server at the start of the run.  An optional `userSetup` is
+ * called afterward so existing setup logic is preserved.
+ *
+ * The server-run ID and a one-time token are written to a temp file so the
+ * reporter instance can pick them up during the streaming handshake.
+ *
+ * @param options   Piwi Dashboard options (uses `serverUrl`, `projectName`, …).
+ * @param userSetup An existing global setup to chain after the Piwi registration.
+ */
+export declare function createGlobalSetup(options?: PiwiDashboardOptions, userSetup?: (config: any) => any): (config: any) => Promise<any>;