@piwitests/reporter 0.5.0 → 0.7.0

package/dist/fixtures.js

@@ -1,336 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dashboardFixtures = void 0;
-exports.extendDashboardFixtures = extendDashboardFixtures;
-const zlib_1 = require("zlib");
-const locator_healing_js_1 = require("./locator-healing.js");
-/**
- * Playwright fixtures that collect network requests, console entries,
- * web vitals, ARIA snapshots, and locator interaction data 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 = [];
-        // ── Locator interaction capture ──────────────────────────────────────
-        // Opt-out: skipped when PIWI_CAPTURE_LOCATORS=false (set automatically when
-        // the reporter's collectPerformanceMetrics / captureLocators is disabled),
-        // so the per-action DOM read + ARIA snapshot cost is never paid when unused.
-        const captureLocators = process.env.PIWI_CAPTURE_LOCATORS !== 'false';
-        const capturedLocators = [];
-        const capturePromises = [];
-        // Locator actions that threw — used at teardown to suggest a fresh locator
-        // from the current page when the element appears renamed/moved.
-        const failedLocators = [];
-        // Chain methods that take args and define a new locator scope (not just narrow).
-        // Origin method/args update to the chain call, e.g. .locator('.item') → locator('.item').
-        // Positional/filter chains that narrow but don't change locator identity.
-        // Origin stays from the page-level call, e.g. .first(), .nth(2), .filter(...).
-        function wrapLocator(locator, originMethod, originArgs) {
-            return new Proxy(locator, {
-                get(target, prop) {
-                    const original = target[prop];
-                    if (typeof original !== 'function')
-                        return original;
-                    if (locator_healing_js_1.CHAIN_METHODS.includes(prop)) {
-                        return (...args) => {
-                            const next = original.apply(target, args);
-                            if (locator_healing_js_1.LOCATOR_CREATING_CHAINS.has(prop)) {
-                                return wrapLocator(next, String(prop), args);
-                            }
-                            return wrapLocator(next, originMethod, originArgs);
-                        };
-                    }
-                    if (!locator_healing_js_1.ACTION_METHODS.includes(prop))
-                        return original;
-                    return async (...callArgs) => {
-                        const seq = capturedLocators.length;
-                        // Capture the test call-site now (sync) so the snapshot's location
-                        // matches the error stack's first user frame — independent of
-                        // pw:api step ordering, worker interleaving, or concurrent actions.
-                        const callerLocation = (0, locator_healing_js_1.captureCallerLocation)();
-                        // Push a placeholder immediately — DOM capture runs async below
-                        capturedLocators.push({
-                            location: callerLocation,
-                            stepIndex: seq,
-                            used: {
-                                method: originMethod,
-                                args: originArgs,
-                                raw: `${originMethod}(${JSON.stringify(originArgs)})`,
-                            },
-                            element: null,
-                            alternatives: [],
-                        });
-                        // The placeholder is already pushed. If the action throws, record
-                        // the failed locator (so teardown can suggest a fresh one for the
-                        // element's current identity) and re-throw so the test still fails.
-                        let result;
-                        try {
-                            result = await original.apply(target, callArgs);
-                        }
-                        catch (err) {
-                            failedLocators.push({ method: originMethod, args: originArgs });
-                            throw err;
-                        }
-                        // Fire-and-forget: capture element data without blocking the test.
-                        // evaluate() can hang when page navigates (element detaches), so
-                        // race it against a 500ms deadline and never throw.
-                        const resolveAttrs = (async () => {
-                            try {
-                                const attrs = (await Promise.race([
-                                    target.evaluate((el, keep) => {
-                                        const attrMap = {};
-                                        for (const key of keep) {
-                                            const v = el.getAttribute(key) ?? el[key];
-                                            attrMap[key] = typeof v === 'string' ? v.slice(0, 200) : v ? String(v).slice(0, 200) : null;
-                                        }
-                                        const r = el.getBoundingClientRect();
-                                        return {
-                                            tagName: el.tagName?.toLowerCase?.() ?? 'unknown',
-                                            attributes: attrMap,
-                                            textContent: (el.textContent || '').trim().slice(0, 80),
-                                            center: {
-                                                x: Math.round(r.x + r.width / 2),
-                                                y: Math.round(r.y + r.height / 2),
-                                            },
-                                        };
-                                    }, [...locator_healing_js_1.CAPTURED_ATTRIBUTES]),
-                                    new Promise((_, reject) => setTimeout(() => reject(new Error('locator capture timeout')), 500)),
-                                ]));
-                                // The browser-computed accessible name only feeds role-based and
-                                // form-field alternatives, so only pay for the extra ARIA
-                                // snapshot when the element actually has a role or is a field.
-                                const role = (0, locator_healing_js_1.resolveAriaRole)({
-                                    tagName: attrs.tagName,
-                                    attributes: attrs.attributes,
-                                    textContent: attrs.textContent,
-                                    accessibleName: null,
-                                    center: attrs.center,
-                                });
-                                const isFormField = ['input', 'select', 'textarea'].includes(attrs.tagName);
-                                // Bound with a timeout: without it, ariaSnapshot waits up to the
-                                // test timeout when the page is mid-navigation, which hangs the
-                                // fixture teardown that drains these capture promises.
-                                const aria = role || isFormField
-                                    ? (await target.ariaSnapshot({ ref: true, timeout: 500 }).catch(() => null))
-                                    : null;
-                                const accessibleName = (0, locator_healing_js_1.extractAccessibleName)(aria) ||
-                                    (0, locator_healing_js_1.approximateAccessibleName)({
-                                        tagName: attrs.tagName,
-                                        attributes: attrs.attributes,
-                                        textContent: attrs.textContent,
-                                        accessibleName: null,
-                                        center: attrs.center,
-                                    });
-                                capturedLocators[seq] = {
-                                    location: callerLocation,
-                                    stepIndex: seq,
-                                    used: {
-                                        method: originMethod,
-                                        args: originArgs,
-                                        raw: `${originMethod}(${JSON.stringify(originArgs)})`,
-                                    },
-                                    element: { ...attrs, accessibleName },
-                                    alternatives: (0, locator_healing_js_1.generateAlternatives)({
-                                        tagName: attrs.tagName,
-                                        attributes: attrs.attributes,
-                                        textContent: attrs.textContent,
-                                        accessibleName,
-                                        center: attrs.center,
-                                    }),
-                                };
-                            }
-                            catch {
-                                // element detached or timeout — keep the placeholder
-                            }
-                        })();
-                        capturePromises.push(resolveAttrs);
-                        return result;
-                    };
-                },
-            });
-        }
-        if (captureLocators) {
-            for (const method of locator_healing_js_1.LOCATOR_METHODS) {
-                const original = page[method].bind(page);
-                page[method] = (...args) => wrapLocator(original(...args), method, args);
-            }
-        }
-        // ── Existing event listeners ──────────────────────────────────────────
-        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 headers = response.headers();
-                        // Response content type (without charset/boundary params) — relevant
-                        // per-request metadata for distinguishing API/JSON vs document/HTML calls.
-                        const contentType = headers['content-type'];
-                        if (contentType)
-                            entry.contentType = contentType.split(';')[0].trim();
-                        const logHeader = 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);
-        // ── Attach locator snapshots ──────────────────────────────────────────
-        // Cap the drain so a stuck capture (e.g. a navigation in flight) can never
-        // hang teardown past the test timeout; per-action evaluate/ariaSnapshot are
-        // already bounded, this is a backstop.
-        await Promise.race([Promise.allSettled(capturePromises), new Promise((resolve) => setTimeout(resolve, 2000))]);
-        if (capturedLocators.length > 0) {
-            await testInfo.attach('piwi-dashboard-locators', {
-                contentType: 'application/json',
-                body: Buffer.from(JSON.stringify(capturedLocators)),
-            });
-        }
-        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,
-                    });
-                    // Suggest a fresh locator for the failed action from the current page.
-                    // When the element was renamed/moved, the pre-captured alternatives
-                    // describe the old element, so this points at where it went now — as a
-                    // Playwright annotation (shown in the report + trace) and an attachment
-                    // (shown in the trace viewer). It does NOT change the locator.
-                    const failed = failedLocators[failedLocators.length - 1];
-                    const suggestion = failed ? (0, locator_healing_js_1.suggestLocatorsFromAria)(failed, snapshot) : null;
-                    if (suggestion) {
-                        testInfo.annotations.push({
-                            type: 'piwi-locator-suggestion',
-                            description: `${suggestion.failing} matched nothing on the failing page — the element may have been renamed or moved. Suggested: ${suggestion.suggestions.join('  |  ')}`,
-                        });
-                        await testInfo.attach('piwi-dashboard-locator-suggestion', {
-                            contentType: 'application/json',
-                            body: Buffer.from(JSON.stringify(suggestion)),
-                        });
-                    }
-                }
-            }
-            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/helpers.d.ts

@@ -1,44 +0,0 @@
-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>;