reporting-labs 0.6.10 → 0.6.12

package/dist/types.d.ts

@@ -17,6 +17,16 @@ export interface ReportingLabsOptions {
     emitJson?: boolean;
     /** File name of the JSON blob inside outputFolder. Default: "report.json" */
     jsonFile?: string;
+    /** Also write a print-ready `report.pdf` next to the HTML, rendered by headless Chromium from the
+     *  report's own PDF layout (executive summary, charts, failure analysis, the full test-case table and
+     *  screenshots of failures). Printed by the Chromium that Playwright provides, else by an installed
+     *  Chrome, Edge or Chromium, whichever browser the tests ran on (Firefox and WebKit runs included). Default: true — set `false` to skip,
+     *  `{ file }` to rename, `{ chromePath }` to name the browser (or set CHROME_PATH). The report also has
+     *  an "Export PDF" button. */
+    pdf?: boolean | {
+        file?: string;
+        chromePath?: string;
+    };
     /** Inline screenshots as base64 (single file, opens anywhere). Default: true */
     embedAttachments?: boolean;
     /** Max size (bytes) of a single attachment to embed. Larger ones are copied as files. Default: 2 MB */

package/dist/wdio/env.d.ts

@@ -0,0 +1,4 @@
+import { ciRunLabel } from '../reporter';
+import type { EnvRow } from '../types';
+export { ciRunLabel };
+export declare function collectEnv(base: string, extra: Record<string, string> | undefined, browsers: string[], workers: number, metadataBranch?: string): EnvRow[];

package/dist/wdio/env.js

@@ -0,0 +1,62 @@
+"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.ciRunLabel = void 0;
+exports.collectEnv = collectEnv;
+/** Environment-card rows for the WDIO report, reusing the Playwright reporter's CI/git helpers. */
+const os = __importStar(require("os"));
+const reporter_1 = require("../reporter");
+Object.defineProperty(exports, "ciRunLabel", { enumerable: true, get: function () { return reporter_1.ciRunLabel; } });
+function collectEnv(base, extra, browsers, workers, metadataBranch) {
+    const env = process.env;
+    const rows = [];
+    rows.push({ k: 'Node', v: process.version });
+    rows.push({ k: 'OS', v: `${os.type()} ${os.release()} (${os.arch()})` });
+    if (browsers.length)
+        rows.push({ k: 'Browsers', v: browsers.join(', ') });
+    if (workers > 1)
+        rows.push({ k: 'Workers', v: String(workers) });
+    const ci = (0, reporter_1.ciLink)(env);
+    if (ci)
+        rows.push({ k: 'CI', v: ci.name, href: ci.url });
+    const git = (0, reporter_1.gitInfo)(base, env);
+    if (git.sha)
+        rows.push({ k: 'Commit', v: `${git.sha.slice(0, 7)}${git.author ? ' · ' + git.author : ''}${git.subject ? ' · ' + git.subject : ''}`, href: git.url });
+    if (git.branch && !metadataBranch)
+        rows.push({ k: 'Branch', v: git.branch });
+    for (const [k, v] of Object.entries(extra || {}))
+        rows.push({ k, v: String(v), href: /^https?:\/\//.test(String(v)) ? String(v) : undefined });
+    return rows;
+}

package/dist/wdio/finalize.d.ts

@@ -0,0 +1,39 @@
+export interface ReportingLabsCompleteOptions {
+    outputFolder?: string;
+    outputFile?: string;
+    jsonFile?: string;
+    emitJson?: boolean;
+    pdf?: boolean | {
+        file?: string;
+        chromePath?: string;
+    };
+    title?: string;
+    logo?: string;
+    accent?: string;
+    theme?: 'auto' | 'light' | 'dark';
+    palette?: 'lab' | 'ocean' | 'ember' | 'mono';
+    metadata?: Record<string, string>;
+    env?: Record<string, string>;
+    sections?: {
+        title: string;
+        html: string;
+    }[];
+    customCss?: string;
+    dimensions?: string[];
+    dimensionOrder?: Record<string, string[]>;
+    project?: unknown;
+    links?: Record<string, unknown>;
+    bdd?: boolean;
+    announce?: boolean;
+    history?: {
+        enabled?: boolean;
+        file?: string;
+        keep?: number;
+    };
+    maskKeys?: string[];
+    maskValues?: string[];
+    maskFromEnv?: boolean;
+    embedFonts?: boolean;
+    editorLinks?: boolean;
+}
+export declare function reportingLabsComplete(options?: ReportingLabsCompleteOptions): Promise<string | undefined>;

package/dist/wdio/finalize.js

@@ -0,0 +1,189 @@
+"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.reportingLabsComplete = reportingLabsComplete;
+/**
+ * Combines the per-runner partials written by the WDIO reporter into the one report —
+ * index.html, report.json and (best-effort) report.pdf. Call it from `onComplete` in wdio.conf:
+ *
+ *   import { reportingLabsComplete } from 'reporting-labs/wdio';
+ *   export const config = {
+ *     reporters: [[ReportingLabsWdioReporter, { outputFolder: 'reporting-labs' }]],
+ *     async onComplete() { await reportingLabsComplete({ outputFolder: 'reporting-labs', title: 'My suite' }); },
+ *   };
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const template_1 = require("../template");
+const mask_1 = require("../mask");
+const pdf_1 = require("../pdf");
+const env_1 = require("./env");
+async function reportingLabsComplete(options = {}) {
+    const outputFolder = options.outputFolder || 'reporting-labs';
+    const partsDir = path.join(outputFolder, '.rl-wdio');
+    if (!fs.existsSync(partsDir))
+        return undefined;
+    const files = fs.readdirSync(partsDir).filter(f => f.endsWith('.json'));
+    if (!files.length)
+        return undefined;
+    const masker = (0, mask_1.makeMasker)(options.maskKeys || [], { knownValues: options.maskValues || [], fromEnv: options.maskFromEnv !== false });
+    const tests = [];
+    let startTime = Number.MAX_SAFE_INTEGER;
+    let endTime = 0;
+    let runStatus = 'passed';
+    const workers = files.length;
+    for (const f of files) {
+        let part;
+        try {
+            part = JSON.parse(fs.readFileSync(path.join(partsDir, f), 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (typeof part.startTime === 'number')
+            startTime = Math.min(startTime, part.startTime);
+        if (typeof part.endTime === 'number')
+            endTime = Math.max(endTime, part.endTime);
+        if (part.runStatus === 'failed')
+            runStatus = 'failed';
+        for (const t of part.tests || [])
+            tests.push(t);
+    }
+    if (startTime === Number.MAX_SAFE_INTEGER)
+        startTime = Date.now();
+    if (!endTime)
+        endTime = Date.now();
+    const stats = { passed: 0, failed: 0, skipped: 0, flaky: 0, timedOut: 0, interrupted: 0, total: tests.length };
+    for (const t of tests)
+        stats[t.outcome]++;
+    const projects = [...new Set(tests.map(t => t.project).filter(Boolean))];
+    const base = process.cwd();
+    const dims = (options.dimensions ?? ['priority', 'severity', 'feature', 'owner']).map(d => d.toLowerCase());
+    const histOn = options.history?.enabled ?? true;
+    const histFile = path.resolve(base, options.history?.file ?? 'reporting-labs.history.json');
+    let entries = [];
+    if (histOn) {
+        try {
+            entries = JSON.parse(fs.readFileSync(histFile, 'utf8'));
+        }
+        catch { /* first run */ }
+    }
+    const failedCount = stats.failed + stats.timedOut + stats.interrupted;
+    const code = (o) => o === 'passed' ? 'p' : o === 'flaky' ? 'k' : o === 'skipped' ? 's' : 'f';
+    const perTest = {};
+    for (const t of tests) {
+        const last = t.results[t.results.length - 1];
+        perTest[t.key] = [code(t.outcome), Math.round(last?.duration ?? t.duration)];
+    }
+    const current = {
+        time: startTime, duration: endTime - startTime,
+        passed: stats.passed, failed: failedCount, flaky: stats.flaky, skipped: stats.skipped, total: stats.total,
+        label: options.metadata?.build ?? (0, env_1.ciRunLabel)(process.env) ?? options.metadata?.branch, tests: perTest,
+    };
+    const history = [...entries, current].slice(-(options.history?.keep ?? 30));
+    if (histOn) {
+        try {
+            fs.writeFileSync(histFile, JSON.stringify(history, null, 1));
+        }
+        catch { /* read-only fs */ }
+    }
+    const metadata = Object.fromEntries(Object.entries(options.metadata ?? {}).map(([k, v]) => [k, masker.maskStr(String(v))]));
+    const bdd = options.bdd ?? tests.some(t => t.results.some(r => r.steps.some(st => /^(Given|When|Then|And|But)\b/.test(st.title))));
+    const data = {
+        title: masker.maskStr(options.title ?? 'Test report'),
+        generatedAt: Date.now(),
+        startTime,
+        duration: endTime - startTime,
+        metadata,
+        projects,
+        workers,
+        stats,
+        tests,
+        history,
+        bdd,
+        rootDir: base,
+        env: (0, env_1.collectEnv)(base, Object.fromEntries(Object.entries(options.env ?? {}).map(([k, v]) => [k, masker.maskStr(String(v))])), [...new Set(projects)], workers, options.metadata?.branch).map(r => ({ ...r, v: masker.maskStr(r.v) })),
+        runStatus,
+        globalErrors: [],
+        globalOutput: [],
+        options: {
+            logo: options.logo,
+            accent: options.accent,
+            theme: options.theme ?? 'auto',
+            palette: options.palette ?? 'lab',
+            embedFonts: options.embedFonts ?? true,
+            sections: options.sections ?? [],
+            widgets: { runStrip: true, outcome: true, attention: true, dimensions: true, timeline: true, durations: true, tags: true, slowest: true, projects: true, flaky: true, environment: true, skipped: true },
+            dimensions: dims,
+            dimensionOrder: {
+                priority: ['P0', 'P1', 'P2', 'P3', 'P4'],
+                severity: ['blocker', 'critical', 'major', 'high', 'medium', 'normal', 'minor', 'low', 'trivial'],
+                ...(options.dimensionOrder ?? {}),
+            },
+            project: options.project,
+            links: Object.fromEntries(Object.entries(options.links ?? {}).map(([k, v]) => [k.toLowerCase(), typeof v === 'string' ? v : v.url])),
+            customCss: options.customCss ?? '',
+            editorLinks: options.editorLinks ?? !process.env.CI,
+        },
+    };
+    fs.mkdirSync(outputFolder, { recursive: true });
+    const htmlFile = path.join(outputFolder, options.outputFile ?? 'index.html');
+    fs.writeFileSync(htmlFile, (0, template_1.renderHtml)(data), 'utf8');
+    if (options.emitJson !== false)
+        fs.writeFileSync(path.join(outputFolder, options.jsonFile ?? 'report.json'), JSON.stringify(data), 'utf8');
+    // tidy the partials
+    try {
+        fs.rmSync(partsDir, { recursive: true, force: true });
+    }
+    catch { /* leave them */ }
+    if (options.announce !== false) {
+        console.log(`\n  reporting-labs: report written to ${path.relative(process.cwd(), htmlFile)}`);
+    }
+    if (options.pdf !== false)
+        await writePdf(htmlFile, outputFolder, options);
+    if (options.announce !== false)
+        console.log('');
+    return htmlFile;
+}
+/** report.pdf next to the HTML; see writeReportPdf for which browser prints it (an installed Chrome or
+ *  Edge when the project has no Playwright). Never fails the run. */
+async function writePdf(htmlFile, outputFolder, options) {
+    const pdfOpt = typeof options.pdf === 'object' ? options.pdf : {};
+    const pdfFile = path.join(outputFolder, pdfOpt.file || 'report.pdf');
+    const r = await (0, pdf_1.writeReportPdf)(htmlFile, pdfFile, pdfOpt.chromePath);
+    if (options.announce === false)
+        return;
+    console.log(r.ok ? `  reporting-labs: PDF written to ${path.relative(process.cwd(), pdfFile)}` : `  reporting-labs: PDF skipped — ${r.reason}`);
+}

package/dist/wdio/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * reportingLabs for WebdriverIO.
+ *
+ *   // wdio.conf.ts
+ *   import ReportingLabsReporter, { reportingLabsComplete } from 'reporting-labs/wdio';
+ *
+ *   export const config = {
+ *     reporters: [[ReportingLabsReporter, { outputFolder: 'reporting-labs' }]],
+ *     async onComplete() { await reportingLabsComplete({ outputFolder: 'reporting-labs', title: 'My suite' }); },
+ *   };
+ */
+import ReportingLabsWdioReporter from './reporter';
+export { ReportingLabsWdioReporter };
+export type { ReportingLabsWdioOptions } from './reporter';
+export { reportingLabsComplete } from './finalize';
+export type { ReportingLabsCompleteOptions } from './finalize';
+export default ReportingLabsWdioReporter;

package/dist/wdio/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportingLabsComplete = exports.ReportingLabsWdioReporter = void 0;
+/**
+ * reportingLabs for WebdriverIO.
+ *
+ *   // wdio.conf.ts
+ *   import ReportingLabsReporter, { reportingLabsComplete } from 'reporting-labs/wdio';
+ *
+ *   export const config = {
+ *     reporters: [[ReportingLabsReporter, { outputFolder: 'reporting-labs' }]],
+ *     async onComplete() { await reportingLabsComplete({ outputFolder: 'reporting-labs', title: 'My suite' }); },
+ *   };
+ */
+const reporter_1 = __importDefault(require("./reporter"));
+exports.ReportingLabsWdioReporter = reporter_1.default;
+var finalize_1 = require("./finalize");
+Object.defineProperty(exports, "reportingLabsComplete", { enumerable: true, get: function () { return finalize_1.reportingLabsComplete; } });
+exports.default = reporter_1.default;

package/dist/wdio/reporter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * reportingLabs reporter for WebdriverIO.
+ *
+ * WDIO drives a reporter by emitting lifecycle events onto it and reading `isSynchronised`, so this
+ * class is a plain EventEmitter — it needs no `@wdio/reporter` at runtime and stays CommonJS, which
+ * loads on every Node version. One instance runs per runner (per spec / worker); it collects that
+ * runner's suites, tests, WebDriver-command steps, errors and (on failure) a screenshot, then writes
+ * a partial JSON. `reportingLabsComplete()` (a one-line `onComplete` hook) combines every partial into
+ * the one report — the same index.html, report.json and report.pdf the Playwright reporter produces.
+ *
+ * Nothing here touches the Playwright reporter; it only reuses the shared, pure helpers.
+ */
+import { EventEmitter } from 'node:events';
+declare const META_KEYS: string[];
+export interface ReportingLabsWdioOptions {
+    outputFolder?: string;
+    title?: string;
+    screenshot?: 'on-failure' | 'always' | 'off';
+    maskKeys?: string[];
+    maskValues?: string[];
+    maskFromEnv?: boolean;
+    [k: string]: unknown;
+}
+export default class ReportingLabsWdioReporter extends EventEmitter {
+    options: ReportingLabsWdioOptions;
+    outputStream: {
+        write: (_c: unknown) => boolean;
+    };
+    private masker;
+    private startTime;
+    private suiteStack;
+    private rlTests;
+    private specs;
+    private cur?;
+    private elTypes;
+    private cid;
+    private capsName;
+    private runStatus;
+    private pending;
+    private endInfo?;
+    private written;
+    constructor(options?: ReportingLabsWdioOptions);
+    /** WDIO polls this before tearing a worker down; we hold it open until the partial is written. */
+    get isSynchronised(): boolean;
+    write(_content: unknown): void;
+    private safe;
+    private onRunnerStart;
+    private onSuiteStart;
+    private onSuiteEnd;
+    private onTestStart;
+    private onBeforeCommand;
+    private onAfterCommand;
+    private endTest;
+    /** Best-effort screenshot of the live session on failure. Async — gated by isSynchronised so the
+     *  partial is written only once it resolves. */
+    private maybeShot;
+    private toError;
+    private onRunnerEnd;
+    private tryWrite;
+    private rel;
+}
+/** Pull meta (priority/severity/owner/...) from WDIO tags like `@priority:P1`, `@P1`, `@critical`. */
+export declare function metaFromTags(tags: string[], dims: string[]): {
+    meta: Record<string, string>;
+    clean: string[];
+};
+export { META_KEYS };