reporting-labs 0.6.10 → 0.6.12

package/dist/wdio/reporter.js

@@ -0,0 +1,332 @@
+"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.META_KEYS = void 0;
+exports.metaFromTags = metaFromTags;
+/**
+ * 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.
+ */
+const node_events_1 = require("node:events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mask_1 = require("../mask");
+const explain_1 = require("../explain");
+const META_KEYS = ['priority', 'severity', 'feature', 'owner', 'epic', 'story', 'issue', 'bug', 'component', 'module', 'team', 'sprint', 'testcase', 'tms', 'requirement'];
+exports.META_KEYS = META_KEYS;
+/** WebDriver command name → readable step verb. Commands not listed (reads, internals) are not steps. */
+const CMD = {
+    navigateTo: 'open', url: 'open', back: 'back', forward: 'forward', refresh: 'refresh',
+    elementClick: 'click', click: 'click', doubleClick: 'double click',
+    elementSendKeys: 'set value', setValue: 'set value', addValue: 'add value', elementClear: 'clear', clearValue: 'clear',
+    findElement: 'find', findElements: 'find all', findElementFromElement: 'find', findElementsFromElement: 'find all',
+    switchToFrame: 'switch to frame', switchToParentFrame: 'switch to parent frame', switchToWindow: 'switch to window',
+    acceptAlert: 'accept alert', dismissAlert: 'dismiss alert', sendAlertText: 'type into alert',
+    performActions: 'perform actions', executeScript: 'execute script', executeAsyncScript: 'execute async script',
+    setWindowRect: 'resize window', maximizeWindow: 'maximize window', minimizeWindow: 'minimize window', fullscreenWindow: 'fullscreen window',
+    uploadFile: 'upload file', addCookie: 'add cookie', deleteCookie: 'delete cookie', deleteAllCookies: 'delete all cookies',
+};
+class ReportingLabsWdioReporter extends node_events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.outputStream = { write: (_c) => true };
+        this.startTime = Date.now();
+        this.suiteStack = [];
+        this.rlTests = [];
+        this.specs = [];
+        this.elTypes = {};
+        this.cid = '';
+        this.capsName = '';
+        this.runStatus = 'passed';
+        this.pending = 0;
+        this.written = false;
+        this.setMaxListeners(0);
+        this.options = options || {};
+        this.masker = (0, mask_1.makeMasker)(this.options.maskKeys || [], { knownValues: this.options.maskValues || [], fromEnv: this.options.maskFromEnv !== false });
+        this.on('runner:start', (r) => this.safe(() => this.onRunnerStart(r)));
+        this.on('suite:start', (s) => this.safe(() => this.onSuiteStart(s)));
+        this.on('suite:end', () => this.safe(() => this.onSuiteEnd()));
+        this.on('test:start', (t) => this.safe(() => this.onTestStart(t)));
+        this.on('test:pass', (t) => this.safe(() => this.endTest(t, 'passed')));
+        this.on('test:fail', (t) => this.safe(() => { this.runStatus = 'failed'; this.endTest(t, 'failed'); }));
+        this.on('test:skip', (t) => this.safe(() => this.endTest(t, 'skipped', t.pendingReason)));
+        this.on('test:pending', (t) => this.safe(() => this.endTest(t, 'skipped', t.pendingReason)));
+        this.on('client:beforeCommand', (c) => this.safe(() => this.onBeforeCommand(c)));
+        this.on('client:afterCommand', (c) => this.safe(() => this.onAfterCommand(c)));
+        this.on('runner:end', () => this.safe(() => this.onRunnerEnd()));
+    }
+    /** WDIO polls this before tearing a worker down; we hold it open until the partial is written. */
+    get isSynchronised() {
+        return this.written || (this.pending === 0 && !this.endInfo);
+    }
+    write(_content) { }
+    safe(fn) { try {
+        fn();
+    }
+    catch { /* a reporter bug must never fail the run */ } }
+    onRunnerStart(runner) {
+        this.startTime = Date.now();
+        this.cid = runner.cid || '';
+        this.specs = runner.specs || [];
+        this.capsName = capsName(runner.capabilities);
+    }
+    onSuiteStart(suite) {
+        if (suite.title)
+            this.suiteStack.push(suite.title);
+    }
+    onSuiteEnd() { this.suiteStack.pop(); }
+    onTestStart(test) {
+        const now = Date.now();
+        const result = {
+            retry: test.retries || 0, status: 'passed', duration: 0, startTime: now, workerIndex: numericCid(this.cid),
+            errors: [], steps: [], attachments: [], stdout: [], stderr: [], logs: [], data: [], api: [],
+        };
+        const file = this.rel(test.file || this.specs[0] || '');
+        const tagSource = [test.title || '', ...this.suiteStack].join(' ');
+        const tags = (tagSource.match(/@[A-Za-z][\w:.=-]*/g) || []);
+        const { meta } = metaFromTags(tags, META_KEYS);
+        const t = {
+            id: test.uid || `${file}:${test.title}`,
+            key: '', title: this.masker.maskStr(test.title || ''), path: this.suiteStack.map(s => this.masker.maskStr(s)),
+            file, line: 0, project: this.capsName, tags, annotations: [], meta,
+            outcome: 'passed', duration: 0, results: [result], retries: test.retries,
+        };
+        t.key = `${t.project}::${t.file}::${[...t.path, t.title].join(' › ')}`;
+        this.cur = { test: t, result, stepStack: [] };
+    }
+    onBeforeCommand(cmd) {
+        if (!this.cur)
+            return;
+        // a value typed into a password / secret field is masked: WDIO reads the element's `type` property
+        // right before typing, so look up what we learned for this element id.
+        const fieldType = this.elTypes[elementId(cmd.endpoint)] || '';
+        const title = cmdTitle(cmd, this.masker, fieldType);
+        if (!title)
+            return;
+        const step = { title, category: 'wdio', duration: 0, steps: [] };
+        step._start = Date.now();
+        const parent = this.cur.stepStack[this.cur.stepStack.length - 1];
+        (parent ? parent.steps : this.cur.result.steps).push(step);
+        this.cur.stepStack.push(step);
+    }
+    onAfterCommand(cmd) {
+        // record element input types so the next sendKeys to that element can be masked
+        if (cmd && cmd.command === 'getElementProperty' && /\/property\/type$/.test(cmd.endpoint || '')) {
+            const id = elementId(cmd.endpoint);
+            const v = cmd.result?.value;
+            if (id && typeof v === 'string')
+                this.elTypes[id] = v;
+        }
+        if (!this.cur)
+            return;
+        const step = this.cur.stepStack.pop();
+        if (step) {
+            step.duration = Date.now() - (step._start || Date.now());
+            delete step._start;
+        }
+    }
+    endTest(test, status, skipReason) {
+        if (!this.cur)
+            this.onTestStart(test); // a skipped / pending test may never fire test:start
+        if (!this.cur)
+            return;
+        const { test: t, result } = this.cur;
+        this.cur.stepStack.length = 0;
+        result.status = status;
+        result.duration = test.duration ?? (Date.now() - result.startTime);
+        let outcome = status;
+        if (status === 'passed' && (test.retries || 0) > 0)
+            outcome = 'flaky';
+        t.outcome = outcome;
+        t.duration = result.duration;
+        if (skipReason) {
+            t.note = skipReason;
+            t.annotations.push({ type: 'skip', description: skipReason });
+        }
+        if (status === 'failed') {
+            const errs = (test.errors && test.errors.length ? test.errors : (test.error ? [test.error] : []));
+            for (const e of errs)
+                result.errors.push(this.toError(e));
+            this.maybeShot(result);
+        }
+        this.rlTests.push(t);
+        this.cur = undefined;
+    }
+    /** Best-effort screenshot of the live session on failure. Async — gated by isSynchronised so the
+     *  partial is written only once it resolves. */
+    maybeShot(result) {
+        if (this.options.screenshot === 'off')
+            return;
+        const b = global.browser;
+        if (!b || typeof b.takeScreenshot !== 'function')
+            return;
+        this.pending++;
+        Promise.resolve()
+            .then(() => b.takeScreenshot())
+            .then((b64) => { if (b64)
+            result.attachments.push({ name: 'screenshot', contentType: 'image/png', src: 'data:image/png;base64,' + b64 }); })
+            .catch(() => { })
+            .finally(() => { this.pending--; this.tryWrite(); });
+    }
+    toError(e) {
+        const message = this.masker.maskStr(stripAnsi(String(e?.message ?? e ?? '')));
+        const stack = e?.stack ? this.masker.maskStr(stripAnsi(String(e.stack))) : undefined;
+        const d = { message };
+        const ex = (0, explain_1.explainError)(message);
+        if (ex)
+            d.explain = ex;
+        if (stack && stack !== message)
+            d.stack = stack;
+        return d;
+    }
+    onRunnerEnd() {
+        this.endInfo = { endTime: Date.now() };
+        this.tryWrite();
+    }
+    tryWrite() {
+        if (!this.endInfo || this.pending > 0 || this.written)
+            return;
+        this.written = true;
+        try {
+            const dir = path.join(this.options.outputFolder || 'reporting-labs', '.rl-wdio');
+            fs.mkdirSync(dir, { recursive: true });
+            const part = { startTime: this.startTime, endTime: this.endInfo.endTime, runStatus: this.runStatus, tests: this.rlTests };
+            const name = `${(this.cid || 'runner').replace(/[^a-z0-9_-]/gi, '_')}-${process.pid}.json`;
+            fs.writeFileSync(path.join(dir, name), JSON.stringify(part));
+        }
+        catch { /* best-effort; finalize will simply see fewer parts */ }
+    }
+    rel(file) {
+        if (!file)
+            return file;
+        try {
+            return path.relative(process.cwd(), file).split(path.sep).join('/');
+        }
+        catch {
+            return file;
+        }
+    }
+}
+exports.default = ReportingLabsWdioReporter;
+function numericCid(cid) {
+    const m = /^(\d+)/.exec(cid || '');
+    return m ? parseInt(m[1], 10) : 0;
+}
+function capsName(caps) {
+    if (!caps)
+        return '';
+    const name = (caps.browserName || caps['appium:deviceName'] || caps.platformName || '');
+    const ver = (caps.browserVersion || caps.version || '');
+    return [name, ver].filter(Boolean).join(' ').trim();
+}
+function stripAnsi(s) { return s.replace(/\x1b\[[0-9;]*m/g, ''); }
+function elementId(endpoint) {
+    const m = /\/element\/([^/]+)\//.exec(endpoint || '');
+    return m ? m[1] : '';
+}
+function cmdTitle(cmd, masker, fieldType = '') {
+    const name = cmd.command || endpointCommand(cmd.endpoint);
+    if (!name)
+        return null;
+    const verb = CMD[name];
+    if (!verb)
+        return null;
+    const body = (cmd.body || {});
+    if (name === 'navigateTo' || name === 'url')
+        return `open ${short(String(body.url ?? ''))}`;
+    if (name === 'findElement' || name === 'findElements' || name === 'findElementFromElement' || name === 'findElementsFromElement') {
+        return `${verb} ${String(body.using ?? '')}: ${short(String(body.value ?? ''))}`.trim();
+    }
+    if (name === 'elementSendKeys' || name === 'setValue' || name === 'addValue') {
+        let text = Array.isArray(body.text) ? body.text.join('') : String(body.text ?? body.value ?? '');
+        text = /password|hidden/i.test(fieldType) ? '****' : masker.maskStr(text);
+        return `${verb} "${short(text)}"`;
+    }
+    if (name === 'executeScript' || name === 'executeAsyncScript') {
+        return `${verb} ${short(String(body.script ?? '').replace(/\s+/g, ' '))}`;
+    }
+    if (name === 'sendAlertText')
+        return 'type into alert';
+    return verb;
+}
+function endpointCommand(endpoint) {
+    if (!endpoint)
+        return null;
+    if (/\/url$/.test(endpoint))
+        return 'navigateTo';
+    if (/\/click$/.test(endpoint))
+        return 'elementClick';
+    if (/\/value$/.test(endpoint))
+        return 'elementSendKeys';
+    if (/\/clear$/.test(endpoint))
+        return 'elementClear';
+    if (/\/elements$/.test(endpoint))
+        return 'findElements';
+    if (/\/element$/.test(endpoint))
+        return 'findElement';
+    return null;
+}
+function short(s, max = 80) { return s.length <= max ? s : s.slice(0, max - 1) + '…'; }
+/** Pull meta (priority/severity/owner/...) from WDIO tags like `@priority:P1`, `@P1`, `@critical`. */
+function metaFromTags(tags, dims) {
+    const meta = {};
+    const clean = [];
+    for (const raw of tags) {
+        const tag = String(raw).replace(/^@/, '');
+        const m = /^([a-z_-]+)[:=](.+)$/i.exec(tag);
+        if (m && dims.includes(m[1].toLowerCase())) {
+            meta[m[1].toLowerCase()] = m[2];
+            continue;
+        }
+        if (/^P[0-4]$/i.test(tag) && dims.includes('priority') && !meta.priority) {
+            meta.priority = tag.toUpperCase();
+            continue;
+        }
+        if (/^(blocker|critical|major|minor|trivial)$/i.test(tag) && dims.includes('severity') && !meta.severity) {
+            meta.severity = tag.toLowerCase();
+            continue;
+        }
+        clean.push(raw);
+    }
+    return { meta, clean };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reporting-labs",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "description": "reportingLabs – beautiful, customizable single-file HTML test reports. One line of config. Playwright adapter included, more runners on the way.",
   "keywords": [
     "test-report",
@@ -29,6 +29,10 @@
     "./auto": {
       "types": "./dist/auto.d.ts",
       "default": "./dist/auto.js"
+    },
+    "./wdio": {
+      "types": "./dist/wdio/index.d.ts",
+      "default": "./dist/wdio/index.js"
     }
   },
   "bin": {
@@ -69,5 +73,10 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
   }
 }