@red-hat-developer-hub/e2e-test-utils 2.1.6 → 2.1.8

package/dist/deployment/rhdh/deployment.js

@@ -242,7 +242,7 @@ export class RHDHDeployment {
     }
     async rolloutRestart() {
         this._log(`Restarting RHDH deployment in namespace ${this.deploymentConfig.namespace}...`);
-        await $ `oc rollout restart deployment -l '${this._labelSelector}' -n ${this.deploymentConfig.namespace}`;
+        await $ `oc rollout restart deployment -l ${this._labelSelector} -n ${this.deploymentConfig.namespace}`;
         this._log(`RHDH deployment restarted successfully in namespace ${this.deploymentConfig.namespace}`);
         await this.waitUntilReady();
     }
@@ -253,9 +253,9 @@ export class RHDHDeployment {
      */
     async scaleDownAndRestart() {
         const namespace = this.deploymentConfig.namespace;
-        await $ `oc scale deployment -l '${this._labelSelector}' --replicas=0 -n ${namespace}`;
-        await $ `oc wait --for=delete pod -l '${this._labelSelector}' -n ${namespace} --timeout=120s || true`;
-        await $ `oc scale deployment -l '${this._labelSelector}' --replicas=1 -n ${namespace}`;
+        await $ `oc scale deployment -l ${this._labelSelector} --replicas=0 -n ${namespace}`;
+        await $ `oc wait --for=delete pod -l ${this._labelSelector} -n ${namespace} --timeout=120s || true`;
+        await $ `oc scale deployment -l ${this._labelSelector} --replicas=1 -n ${namespace}`;
     }
     async waitUntilReady(timeout = 500) {
         const namespace = this.deploymentConfig.namespace;

package/dist/playwright/coverage.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The whole `__coverage__` object, keyed by each instrumented file's path.
+ *
+ * Named for what it holds: istanbul's own `CoverageData` is the entry for a
+ * single file, so calling this that would read as one file's counters.
+ *
+ * The values stay `unknown` on purpose — this module serializes them and never
+ * reads inside, so modelling istanbul's report shape would buy nothing and pull
+ * a dependency on its types into a package that has none.
+ */
+export type CoverageMap = Record<string, unknown>;
+export type PageLike = {
+    isClosed(): boolean;
+    evaluate(pageFunction: () => CoverageMap | undefined): Promise<CoverageMap | undefined>;
+};
+export type BrowserLike = {
+    contexts(): readonly {
+        pages(): readonly PageLike[];
+    }[];
+};
+/** One page's coverage, tagged so repeated reads of it can overwrite. */
+export type CoverageEntry = {
+    pageId: string;
+    coverage: CoverageMap;
+};
+/**
+ * Every non-empty coverage map reachable in the browser, one entry per page.
+ *
+ * Only the plugin under test is instrumented, so `__coverage__` appears solely
+ * in pages that loaded its bundle. Which page that is depends on how the spec
+ * is written — some drive Playwright's `page` fixture, others open their own
+ * context in `beforeAll` and run every test there — so this walks every open
+ * context rather than assuming one.
+ *
+ * A page carrying an empty object is dropped: it is as useless as a page with
+ * none, and reporting it as a find would mask the "nothing was instrumented"
+ * case the caller reports on.
+ *
+ * Failures are handled at two levels on purpose. A single unusable page is
+ * skipped, because the other pages' coverage is still worth having. A failure
+ * reaching the browser propagates: returning an empty array would be
+ * indistinguishable from "nothing was instrumented", and the caller can only
+ * report accurately what it is allowed to see.
+ */
+export declare function collectCoverageFromBrowser(browser: BrowserLike): Promise<CoverageEntry[]>;
+/** Every reason collection can legitimately come back with nothing. */
+export declare const NO_COVERAGE_FOUND_MESSAGE: string;
+/**
+ * Collect and persist one JSON per covered page, reporting instead of throwing.
+ *
+ * Called from fixture teardown for every test, so it must never raise: an
+ * unwritable output directory or a browser that died mid-test would otherwise
+ * fail a test that had already passed. Coverage is diagnostics, not a verdict.
+ * `report` is how a problem stays visible without becoming one — silence is the
+ * failure mode this module exists to remove.
+ *
+ * Files are named per page, not per test, and deliberately overwritten. A
+ * context opened in `beforeAll` outlives the whole file, and `__coverage__`
+ * accumulates in it, so naming per test would write a growing copy of the same
+ * map once per test — 30 near-duplicates of a multi-megabyte report, all summed
+ * again by `nyc merge`. Overwriting keeps the last and most complete read, and
+ * costs nothing for a per-test fixture page, which is a new page with a new id
+ * every time. It also collapses the retry case, where a failed and a passing
+ * attempt would otherwise both be counted.
+ */
+export declare function collectAndWriteCoverage(browser: BrowserLike, target: {
+    dir: string;
+    runId: string;
+}, report: (detail: string) => void): Promise<void>;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/playwright/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/playwright/coverage.ts"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAElD,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,IAAI,OAAO,CAAC;IAIpB,QAAQ,CACN,YAAY,EAAE,MAAM,WAAW,GAAG,SAAS,GAC1C,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,IAAI,SAAS;QAAE,KAAK,IAAI,SAAS,QAAQ,EAAE,CAAA;KAAE,EAAE,CAAC;CACzD,CAAC;AAEF,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAE,CAAC;AAmCtE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,aAAa,EAAE,CAAC,CAmB1B;AAED,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,QAGqC,CAAC;AAE5E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EACtC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAC/B,OAAO,CAAC,IAAI,CAAC,CAiBf"}

package/dist/playwright/coverage.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Stable per-page id, so a page read across many tests keeps one identity.
+ *
+ * Weakly held: pages are closed and discarded constantly, and keeping them
+ * alive to remember a number would be a leak that grows with the suite.
+ */
+const pageIds = new WeakMap();
+let nextPageId = 0;
+function idFor(page) {
+    const existing = pageIds.get(page);
+    if (existing !== undefined)
+        return existing;
+    const id = `page${nextPageId++}`;
+    pageIds.set(page, id);
+    return id;
+}
+/**
+ * Runs in the browser, so it must not close over anything.
+ *
+ * The assertion stands in for a type that cannot exist statically: nyc defines
+ * `__coverage__` at runtime, in the instrumented bundle. Declaring it as a
+ * global would be the alternative, but this package is published, and its
+ * ambient declarations would land in every consumer's type environment.
+ */
+function readCoverageGlobal() {
+    return globalThis.__coverage__;
+}
+/**
+ * Every non-empty coverage map reachable in the browser, one entry per page.
+ *
+ * Only the plugin under test is instrumented, so `__coverage__` appears solely
+ * in pages that loaded its bundle. Which page that is depends on how the spec
+ * is written — some drive Playwright's `page` fixture, others open their own
+ * context in `beforeAll` and run every test there — so this walks every open
+ * context rather than assuming one.
+ *
+ * A page carrying an empty object is dropped: it is as useless as a page with
+ * none, and reporting it as a find would mask the "nothing was instrumented"
+ * case the caller reports on.
+ *
+ * Failures are handled at two levels on purpose. A single unusable page is
+ * skipped, because the other pages' coverage is still worth having. A failure
+ * reaching the browser propagates: returning an empty array would be
+ * indistinguishable from "nothing was instrumented", and the caller can only
+ * report accurately what it is allowed to see.
+ */
+export async function collectCoverageFromBrowser(browser) {
+    const collected = [];
+    for (const context of browser.contexts()) {
+        for (const page of context.pages()) {
+            if (page.isClosed())
+                continue;
+            let coverage;
+            try {
+                coverage = await page.evaluate(readCoverageGlobal);
+            }
+            catch {
+                // A page can crash, navigate, or close between being listed and being
+                // evaluated. One unusable page must not discard the others' coverage.
+                continue;
+            }
+            if (coverage && Object.keys(coverage).length > 0) {
+                collected.push({ pageId: idFor(page), coverage });
+            }
+        }
+    }
+    return collected;
+}
+/** Every reason collection can legitimately come back with nothing. */
+export const NO_COVERAGE_FOUND_MESSAGE = "E2E_COLLECT_COVERAGE=true but no open page exposed __coverage__. The " +
+    "deployed bundle may not be instrumented, the spec may have closed its " +
+    "pages before teardown, or evaluation may have been blocked in the page.";
+/**
+ * Collect and persist one JSON per covered page, reporting instead of throwing.
+ *
+ * Called from fixture teardown for every test, so it must never raise: an
+ * unwritable output directory or a browser that died mid-test would otherwise
+ * fail a test that had already passed. Coverage is diagnostics, not a verdict.
+ * `report` is how a problem stays visible without becoming one — silence is the
+ * failure mode this module exists to remove.
+ *
+ * Files are named per page, not per test, and deliberately overwritten. A
+ * context opened in `beforeAll` outlives the whole file, and `__coverage__`
+ * accumulates in it, so naming per test would write a growing copy of the same
+ * map once per test — 30 near-duplicates of a multi-megabyte report, all summed
+ * again by `nyc merge`. Overwriting keeps the last and most complete read, and
+ * costs nothing for a per-test fixture page, which is a new page with a new id
+ * every time. It also collapses the retry case, where a failed and a passing
+ * attempt would otherwise both be counted.
+ */
+export async function collectAndWriteCoverage(browser, target, report) {
+    try {
+        const collected = await collectCoverageFromBrowser(browser);
+        if (collected.length === 0) {
+            report(NO_COVERAGE_FOUND_MESSAGE);
+            return;
+        }
+        fs.mkdirSync(target.dir, { recursive: true });
+        for (const { pageId, coverage } of collected) {
+            fs.writeFileSync(path.join(target.dir, `${target.runId}-${pageId}.json`), JSON.stringify(coverage));
+        }
+    }
+    catch (error) {
+        report(`collection failed: ${error}`);
+    }
+}

package/dist/playwright/coverage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coverage.test.d.ts.map

package/dist/playwright/coverage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.test.d.ts","sourceRoot":"","sources":["../../src/playwright/coverage.test.ts"],"names":[],"mappings":""}

package/dist/playwright/coverage.test.js

@@ -0,0 +1,240 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import fs from "fs-extra";
+import path from "node:path";
+import os from "node:os";
+import { collectAndWriteCoverage, collectCoverageFromBrowser, NO_COVERAGE_FOUND_MESSAGE, } from "./coverage.js";
+/** Reports read back off disk arrive in directory order, so sort by content. */
+function byFirstKey(a, b) {
+    return Object.keys(a)[0].localeCompare(Object.keys(b)[0]);
+}
+/**
+ * A page whose `__coverage__` is whatever `coverage` says.
+ *
+ * `evaluate` receives the real callback and would normally run it in the
+ * browser against that page's `globalThis`. There is no browser here, so the
+ * fake answers for it — which is the whole point: the behaviour under test is
+ * which pages get asked and what happens to the answers, not how Playwright
+ * ships a function across the wire.
+ */
+function fakePage(coverage, { closed = false } = {}) {
+    return {
+        isClosed: () => closed,
+        evaluate: async () => coverage,
+    };
+}
+function unusablePage(reason) {
+    return {
+        isClosed: () => false,
+        evaluate: async () => {
+            throw new Error(reason);
+        },
+    };
+}
+/**
+ * The one fake that really runs the callback, against a `globalThis` carrying
+ * what an instrumented bundle would have left behind.
+ *
+ * Every other fake answers in place of `evaluate`, which leaves the function
+ * that actually names `__coverage__` unexercised — rename it and the suite
+ * stays green while collection silently returns nothing, one level below the
+ * regression this module exists to end.
+ */
+function evaluatingPage(globals) {
+    return {
+        isClosed: () => false,
+        evaluate: async (pageFunction) => {
+            const target = globalThis;
+            const restore = Object.keys(globals).map((key) => [key, key in target, target[key]]);
+            Object.assign(target, globals);
+            try {
+                return pageFunction();
+            }
+            finally {
+                for (const [key, existed, previous] of restore) {
+                    if (existed)
+                        target[key] = previous;
+                    else
+                        delete target[key];
+                }
+            }
+        },
+    };
+}
+function fakeBrowser(...contexts) {
+    return { contexts: () => contexts.map((pages) => ({ pages: () => pages })) };
+}
+/** Istanbul keys its report by the instrumented file's absolute path. */
+function coverageFor(file) {
+    return { [file]: { path: file } };
+}
+const COVERAGE = coverageFor("/src/plugin.tsx");
+const OTHER_COVERAGE = coverageFor("/src/widget.tsx");
+/** The coverage maps alone; page identity is asserted on its own below. */
+async function mapsFrom(browser) {
+    const collected = await collectCoverageFromBrowser(browser);
+    return collected.map((entry) => entry.coverage);
+}
+describe("collectCoverageFromBrowser", () => {
+    it("collects from a context the spec opened itself", async () => {
+        // The regression this exists for. Specs that run every test in their own
+        // `browser.newContext()` reported zero coverage for months while passing,
+        // because collection only ever looked at the fixture page.
+        const fixturePage = fakePage(undefined);
+        const specOwnedPage = fakePage(COVERAGE);
+        const collected = await mapsFrom(fakeBrowser([fixturePage], [specOwnedPage]));
+        assert.deepStrictEqual(collected, [COVERAGE]);
+    });
+    it("returns one entry per covered context so nyc merge sums them", async () => {
+        const collected = await mapsFrom(fakeBrowser([fakePage(COVERAGE)], [fakePage(OTHER_COVERAGE)]));
+        assert.deepStrictEqual(collected, [COVERAGE, OTHER_COVERAGE], "entries stay separate; merging is nyc's job, not this function's");
+    });
+    it("collects from every page in a context, not just the first", async () => {
+        // One `newContext()` can hold several pages — a popup, a second tab. Taking
+        // `pages()[0]` would satisfy every other case in this suite.
+        const collected = await mapsFrom(fakeBrowser([
+            fakePage(undefined),
+            fakePage(COVERAGE),
+            fakePage(OTHER_COVERAGE),
+        ]));
+        assert.deepStrictEqual(collected, [COVERAGE, OTHER_COVERAGE], "every page of a context is probed, in page order");
+    });
+    it("moves past a context holding no pages", async () => {
+        const collected = await mapsFrom(fakeBrowser([], [fakePage(COVERAGE)]));
+        assert.deepStrictEqual(collected, [COVERAGE]);
+    });
+    it("reads __coverage__ off the page's own globalThis", async () => {
+        const collected = await mapsFrom(
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        fakeBrowser([evaluatingPage({ __coverage__: COVERAGE })]));
+        assert.deepStrictEqual(collected, [COVERAGE], "the global nyc writes is the global this reads");
+    });
+    it("finds nothing in a page that loaded no instrumented bundle", async () => {
+        const collected = await mapsFrom(fakeBrowser([evaluatingPage({})]));
+        assert.deepStrictEqual(collected, []);
+    });
+    it("keeps other pages' coverage when one page cannot be evaluated", async () => {
+        const collected = await mapsFrom(fakeBrowser([unusablePage("Target page, context or browser has been closed")], [fakePage(COVERAGE)]));
+        assert.deepStrictEqual(collected, [COVERAGE], "a single crashed page used to discard the whole test's coverage");
+    });
+    it("skips closed pages without evaluating them", async () => {
+        let evaluated = false;
+        const closedPage = {
+            isClosed: () => true,
+            evaluate: async () => {
+                evaluated = true;
+                return COVERAGE;
+            },
+        };
+        const collected = await mapsFrom(fakeBrowser([closedPage]));
+        assert.deepStrictEqual(collected, []);
+        assert.strictEqual(evaluated, false, "a closed page must not be probed");
+    });
+    it("ignores a page with no coverage", async () => {
+        const collected = await mapsFrom(fakeBrowser([fakePage(undefined)]));
+        assert.deepStrictEqual(collected, []);
+    });
+    it("ignores an empty coverage object", async () => {
+        // An instrumented bundle that never executed leaves `{}` behind. Treating
+        // it as a find would write an empty JSON and suppress the warning that is
+        // supposed to flag exactly this.
+        const collected = await mapsFrom(fakeBrowser([fakePage({})]));
+        assert.deepStrictEqual(collected, []);
+    });
+    it("returns nothing when no context is open", async () => {
+        assert.deepStrictEqual(await mapsFrom(fakeBrowser()), []);
+    });
+    it("propagates a browser-level failure instead of reporting no coverage", async () => {
+        // The caller turns this into a diagnostic that names the real cause.
+        // Swallowing it here would return an empty array indistinguishable from
+        // "nothing was instrumented" — the confusion this module exists to end.
+        const deadBrowser = {
+            contexts: () => {
+                throw new Error("Browser has been closed");
+            },
+        };
+        await assert.rejects(() => collectCoverageFromBrowser(deadBrowser), /Browser has been closed/);
+    });
+    it("gives one page the same id across collections", async () => {
+        // What makes the per-page filename overwrite instead of accumulate: a
+        // context opened in `beforeAll` is read again on every test, and each read
+        // returns the same growing map.
+        const longLived = fakePage(COVERAGE);
+        const browser = fakeBrowser([longLived]);
+        const first = await collectCoverageFromBrowser(browser);
+        const second = await collectCoverageFromBrowser(browser);
+        assert.strictEqual(first[0].pageId, second[0].pageId);
+    });
+    it("gives distinct pages distinct ids", async () => {
+        const collected = await collectCoverageFromBrowser(fakeBrowser([fakePage(COVERAGE)], [fakePage(OTHER_COVERAGE)]));
+        assert.notStrictEqual(collected[0].pageId, collected[1].pageId, "sharing an id would make one page's file overwrite another's");
+    });
+});
+describe("collectAndWriteCoverage", () => {
+    async function inTempDir(run) {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "coverage-test-"));
+        try {
+            await run(dir);
+        }
+        finally {
+            await fs.remove(dir);
+        }
+    }
+    it("writes one file per page, both readable back", async () => {
+        await inTempDir(async (dir) => {
+            const reported = [];
+            await collectAndWriteCoverage(fakeBrowser([fakePage(COVERAGE)], [fakePage(OTHER_COVERAGE)]), { dir, runId: "w0" }, (detail) => reported.push(detail));
+            const files = (await fs.readdir(dir)).sort();
+            assert.strictEqual(files.length, 2, "two pages must not collide");
+            const written = await Promise.all(files.map((file) => fs.readJson(path.join(dir, file))));
+            assert.deepStrictEqual(written.sort(byFirstKey), [
+                COVERAGE,
+                OTHER_COVERAGE,
+            ]);
+            assert.deepStrictEqual(reported, [], "a clean run reports nothing");
+        });
+    });
+    it("overwrites rather than accumulating when a page is read again", async () => {
+        // The long-lived-context case: 34 tests must not leave 34 copies of the
+        // same growing map for `nyc merge` to sum.
+        await inTempDir(async (dir) => {
+            const browser = fakeBrowser([fakePage(COVERAGE)]);
+            await collectAndWriteCoverage(browser, { dir, runId: "w0" }, () => { });
+            await collectAndWriteCoverage(browser, { dir, runId: "w0" }, () => { });
+            assert.strictEqual((await fs.readdir(dir)).length, 1);
+        });
+    });
+    it("reports instead of throwing when the browser is gone", async () => {
+        await inTempDir(async (dir) => {
+            const reported = [];
+            const deadBrowser = {
+                contexts: () => {
+                    throw new Error("Browser has been closed");
+                },
+            };
+            await collectAndWriteCoverage(deadBrowser, { dir, runId: "w0" }, (detail) => reported.push(detail));
+            assert.strictEqual(reported.length, 1);
+            assert.match(reported[0], /Browser has been closed/, "the report must name the real cause, not just 'no coverage'");
+        });
+    });
+    it("reports instead of throwing when the directory cannot be created", async () => {
+        // Teardown runs for every test, so an unwritable outputDir must not be able
+        // to fail a test that already passed.
+        await inTempDir(async (dir) => {
+            const blocked = path.join(dir, "a-file-not-a-dir");
+            await fs.writeFile(blocked, "");
+            const reported = [];
+            await collectAndWriteCoverage(fakeBrowser([fakePage(COVERAGE)]), { dir: blocked, runId: "w0" }, (detail) => reported.push(detail));
+            assert.strictEqual(reported.length, 1);
+            assert.match(reported[0], /collection failed/);
+        });
+    });
+    it("reports the no-coverage diagnosis when nothing is instrumented", async () => {
+        await inTempDir(async (dir) => {
+            const reported = [];
+            await collectAndWriteCoverage(fakeBrowser([fakePage(undefined)]), { dir, runId: "w0" }, (detail) => reported.push(detail));
+            assert.deepStrictEqual(reported, [NO_COVERAGE_FOUND_MESSAGE]);
+            assert.strictEqual(await fs.pathExists(dir), true, "reporting must not depend on having written anything");
+        });
+    });
+});

package/dist/playwright/fixtures/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/playwright/fixtures/test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAMzC,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;IACzB,eAAe,EAAE,IAAI,CAAC;IAEtB,kBAAkB,EAAE,IAAI,CAAC;CAC1B,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAClC,oBAAoB,EAAE,cAAc,CAAC;CACtC,CAAC;AA4FF,eAAO,MAAM,IAAI;;CAEf,CAAC;AAEH,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/playwright/fixtures/test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAuBzC,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;IACzB,eAAe,EAAE,IAAI,CAAC;IAEtB,kBAAkB,EAAE,IAAI,CAAC;CAC1B,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAClC,oBAAoB,EAAE,cAAc,CAAC;CACtC,CAAC;AA4FF,eAAO,MAAM,IAAI;;CAEf,CAAC;AAEH,cAAc,kBAAkB,CAAC"}

package/dist/playwright/fixtures/test.js

@@ -4,8 +4,25 @@ import { LoginHelper, UIhelper } from "../helpers/index.js";
 import { runOnce } from "../run-once.js";
 import { $ } from "../../utils/bash.js";
 import { WorkspacePaths } from "../../utils/workspace-paths.js";
-import fs from "node:fs";
+import { collectAndWriteCoverage } from "../coverage.js";
+import { isCoverageEnabled } from "../../utils/common.js";
 import path from "path";
+// Asking for coverage and getting none used to look exactly like success: the
+// collector returned quietly and the run stayed green while every JSON was
+// lost. Reporting it is deliberately two-channel — an annotation lands in the
+// HTML report beside the result, the way `autoAnnotations` below does, and a
+// console line keeps it in the CI log, where a green run is still read.
+//
+// Deduplicated by message rather than by a single flag: one recurring
+// "no coverage found" must not be what silences the first real exception.
+const loggedCoverageProblems = new Set();
+function reportCoverageProblem(testInfo, detail) {
+    testInfo.annotations.push({ type: "coverage", description: detail });
+    if (loggedCoverageProblems.has(detail))
+        return;
+    loggedCoverageProblems.add(detail);
+    console.warn(`[coverage] ${detail}`);
+}
 const baseTest = base.extend({
     rhdhDeploymentWorker: [
         // eslint-disable-next-line no-empty-pattern
@@ -59,21 +76,25 @@ const baseTest = base.extend({
     ],
     // eslint-disable-next-line @typescript-eslint/naming-convention
     _coverageCollector: [
-        async ({ page }, use, testInfo) => {
+        // Reads through `browser` so a context the spec opened itself is seen too,
+        // but must also depend on `context`. Playwright sets auto fixtures up
+        // before the ones a test asks for and tears them down in reverse, so
+        // depending on `browser` alone puts this after the context fixture has
+        // already closed — `browser.contexts()` comes back empty and every spec
+        // driving the plain `page` fixture reports nothing. Naming `context` makes
+        // this a dependent of it, which is what orders teardown correctly. It is
+        // still lighter than depending on `page`: a context is created, not a page.
+        async ({ browser, context }, use, testInfo) => {
+            void context; // Depended on for teardown ordering, not for its value.
             await use();
-            if (process.env.E2E_COLLECT_COVERAGE !== "true")
+            if (!isCoverageEnabled())
                 return;
-            try {
-                const coverage = await page.evaluate(() => globalThis.__coverage__);
-                if (!coverage)
-                    return;
-                const dir = path.join(testInfo.project.outputDir, "coverage");
-                fs.mkdirSync(dir, { recursive: true });
-                fs.writeFileSync(path.join(dir, `${testInfo.testId}-${Date.now()}.json`), JSON.stringify(coverage));
-            }
-            catch {
-                // Best-effort: page may have crashed or been closed
-            }
+            await collectAndWriteCoverage(browser, {
+                dir: path.join(testInfo.project.outputDir, "coverage"),
+                // Unique per worker process, so two workers writing the same
+                // project's outputDir cannot land on the same filename.
+                runId: `w${testInfo.workerIndex}`,
+            }, (detail) => reportCoverageProblem(testInfo, detail));
         },
         { auto: true, scope: "test" },
     ],

package/dist/utils/common.d.ts

@@ -1,4 +1,12 @@
 declare function envsubst(str: string, env?: NodeJS.ProcessEnv): string;
 declare function requireEnv(...varNames: [string, ...string[]]): void;
-export { envsubst, requireEnv };
+/**
+ * Whether this run should deploy instrumented bundles and collect coverage.
+ *
+ * Read from two layers that have to agree — plugin resolution picks the
+ * `__coverage` OCI tag, the Playwright fixture reads `__coverage__` back out —
+ * so the check lives in one place rather than as a string compare in each.
+ */
+declare function isCoverageEnabled(): boolean;
+export { envsubst, requireEnv, isCoverageEnabled };
 //# sourceMappingURL=common.d.ts.map

package/dist/utils/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/utils/common.ts"],"names":[],"mappings":"AAAA,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,oBAAc,UAS/C;AAED,iBAAS,UAAU,CAAC,GAAG,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAO5D;AAED,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/utils/common.ts"],"names":[],"mappings":"AAAA,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,oBAAc,UAS/C;AAED,iBAAS,UAAU,CAAC,GAAG,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAO5D;AAED;;;;;;GAMG;AACH,iBAAS,iBAAiB,IAAI,OAAO,CAEpC;AAED,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/utils/common.js

@@ -13,4 +13,14 @@ function requireEnv(...varNames) {
         }
     }
 }
-export { envsubst, requireEnv };
+/**
+ * Whether this run should deploy instrumented bundles and collect coverage.
+ *
+ * Read from two layers that have to agree — plugin resolution picks the
+ * `__coverage` OCI tag, the Playwright fixture reads `__coverage__` back out —
+ * so the check lives in one place rather than as a string compare in each.
+ */
+function isCoverageEnabled() {
+    return process.env.E2E_COLLECT_COVERAGE === "true";
+}
+export { envsubst, requireEnv, isCoverageEnabled };

package/dist/utils/plugin-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-metadata.d.ts","sourceRoot":"","sources":["../../src/utils/plugin-metadata.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAgBD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAID;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAqBtC;AAoBD;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA+CjE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAc3D;AAID;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI5D;AAYD,eAAO,MAAM,qBAAqB,gBAAgB,CAAC;AAEnD,wBAAgB,oBAAoB,CAClC,YAAY,GAAE,MAA8B,GAC3C,MAAM,GAAG,IAAI,CAQf;AAED,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CA2BzB;AAED,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAwBtC;AA2JD;;;;;;;GAOG;AACH;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAMT;AA0HD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAajE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,oBAAoB,CAuBtE;AAED;;;;;;;GAOG;AACH,wBAAsB,2BAA2B,CAC/C,YAAY,GAAE,MAA8B,GAC3C,OAAO,CAAC,oBAAoB,CAAC,CAwB/B;AA2BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,oBAAoB,EAC5B,YAAY,GAAE,MAA8B,EAC5C,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,oBAAoB,CAAC,CAsC/B"}
+{"version":3,"file":"plugin-metadata.d.ts","sourceRoot":"","sources":["../../src/utils/plugin-metadata.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAgBD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAID;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAqBtC;AAoBD;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA+CjE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAc3D;AAID;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI5D;AAYD,eAAO,MAAM,qBAAqB,gBAAgB,CAAC;AAEnD,wBAAgB,oBAAoB,CAClC,YAAY,GAAE,MAA8B,GAC3C,MAAM,GAAG,IAAI,CAQf;AAED,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CA2BzB;AAED,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAwBtC;AA2JD;;;;;;;GAOG;AACH;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAMT;AAyHD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAajE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,oBAAoB,CAuBtE;AAED;;;;;;;GAOG;AACH,wBAAsB,2BAA2B,CAC/C,YAAY,GAAE,MAA8B,GAC3C,OAAO,CAAC,oBAAoB,CAAC,CAwB/B;AA2BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,oBAAoB,EAC5B,YAAY,GAAE,MAA8B,EAC5C,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,oBAAoB,CAAC,CAsC/B"}

package/dist/utils/plugin-metadata.js

@@ -3,6 +3,7 @@ import path from "path";
 import yaml from "js-yaml";
 import { glob } from "zx";
 import { deepMerge } from "./merge-yamls.js";
+import { isCoverageEnabled } from "./common.js";
 const OCI_REGISTRY_PREFIX = "oci://ghcr.io/redhat-developer/rhdh-plugin-export-overlays";
 // ── Detection ─────────────────────────────────────────────────────────────────
 /**
@@ -302,8 +303,7 @@ async function resolvePluginPackages(plugins, metadataMap, metadataPath, dpdyPac
             if (prOciUrls) {
                 const prUrl = prOciUrls.get(displayName);
                 if (prUrl) {
-                    const usesCoverage = process.env.E2E_COLLECT_COVERAGE === "true" &&
-                        metadata.role === "frontend-plugin";
+                    const usesCoverage = isCoverageEnabled() && metadata.role === "frontend-plugin";
                     const resolved = usesCoverage
                         ? prUrl.replace(/(:[^!]+)/, "$1__coverage")
                         : prUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@red-hat-developer-hub/e2e-test-utils",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "Test utilities for RHDH E2E tests",
   "license": "Apache-2.0",
   "repository": {