@piwitests/reporter 0.43.0 → 0.45.0

package/dist/cli/index.js

@@ -1752,8 +1752,12 @@ function samePage(a, b) {
   const kb = pageKey(b);
   return ka === null || kb === null || ka === kb;
 }
+function viewportLine(viewport) {
+  return `  await page.setViewportSize({ width: ${Math.round(viewport.width)}, height: ${Math.round(viewport.height)} });`;
+}
 function renderSpec(session, options = {}) {
   const { steps } = session;
+  const viewportAt = new Map((session.viewports ?? []).map((v) => [v.step, v]));
   const title = options.title ?? "recorded flow";
   const catalog = (options.catalog ?? []).filter(callIdentifiersAreSafe);
   const ctx = {
@@ -1781,6 +1785,8 @@ function renderSpec(session, options = {}) {
   let sawGoto = false;
   while (pos < steps.length) {
     const step = steps[pos];
+    const viewport = pos > 0 ? viewportAt.get(pos) : void 0;
+    if (viewport) bodyLines.push(viewportLine(viewport));
     stepStarts[pos] = bodyLines.length;
     if (step.action === "goto") {
       bodyLines.push(...renderRawStep(step, pos, ctx));
@@ -1788,7 +1794,8 @@ function renderSpec(session, options = {}) {
       pos++;
       continue;
     }
-    const match = catalog.length > 0 ? matchFunctionAt(steps, pos, catalog) : null;
+    const found = catalog.length > 0 ? matchFunctionAt(steps, pos, catalog) : null;
+    const match = found && ![...viewportAt.keys()].some((at) => at > pos && at <= Math.max(...found.matchedIndices)) ? found : null;
     if (match) {
       bodyLines.push(renderFunctionCall(match));
       usedEntries.push(match.entry);
@@ -1803,11 +1810,13 @@ function renderSpec(session, options = {}) {
     checkNextPage(pos);
     pos++;
   }
-  let bodyOffset = 0;
-  if (!sawGoto && session.startUrl) {
-    bodyLines.unshift(`  await page.goto(${quote2(urlForCode(session.startUrl, ctx))});`);
-    bodyOffset = 1;
-  }
+  const start = viewportAt.get(0);
+  const opening = [
+    ...start ? [viewportLine(start)] : [],
+    ...!sawGoto && session.startUrl ? [`  await page.goto(${quote2(urlForCode(session.startUrl, ctx))});`] : []
+  ];
+  bodyLines.unshift(...opening);
+  const bodyOffset = opening.length;
   const importLines = renderImports(usedEntries);
   const instantiationLines = renderInstantiations(usedEntries);
   const failLine = expectFailLine(options);
@@ -1825,7 +1834,7 @@ function renderSpec(session, options = {}) {
     };
   }
   const details = renderDetails(options);
-  const opening = details.length > 0 ? [`test(${quote2(title)}, {`, ...details, `}, async ({ page }) => {`] : [`test(${quote2(title)}, async ({ page }) => {`];
+  const testOpening = details.length > 0 ? [`test(${quote2(title)}, {`, ...details, `}, async ({ page }) => {`] : [`test(${quote2(title)}, async ({ page }) => {`];
   const lines = [
     // Package name interpolated rather than adjoining the preceding keyword
     // directly, so this generated-code line does not itself look like a real
@@ -1833,12 +1842,12 @@ function renderSpec(session, options = {}) {
     `import { test, expect } from ${quote2(options.testImport?.trim() || "@playwright/test")};`,
     ...importLines,
     ``,
-    ...opening,
+    ...testOpening,
     ...testBody,
     `});`,
     ``
   ];
-  const header = 1 + importLines.length + 1 + opening.length;
+  const header = 1 + importLines.length + 1 + testOpening.length;
   return { code: lines.join("\n"), matchedSpans, warnings: ctx.warnings, stepLines: linesFrom(header) };
 }
 
@@ -1850,7 +1859,12 @@ var STEPS_LIMITS = {
   /** Typed values, expected values, URLs, notes. */
   valueLength: 2e3,
   /** Titles, names, texts, locators. */
-  textLength: 500
+  textLength: 500,
+  viewports: 50,
+  /** The widest and tallest viewport, in CSS pixels. */
+  viewportSize: 1e4,
+  /** The browser's zoom factors a viewport may name, as browsers allow them. */
+  zoom: { min: 0.25, max: 5 }
 };
 var ACTIONS = /* @__PURE__ */ new Set([
   "goto",
@@ -1895,13 +1909,14 @@ function toStepsDocument(session, meta = {}) {
     origin,
     recordedAt: session.startedAt,
     note: meta.note ?? null,
-    steps: session.steps.map((step) => ({
+    steps: session.steps.map(({ view: _view, ...step }) => ({
       ...step,
       target: step.target ? withoutElementKey(step.target) : null,
       ...step.dropTarget ? { dropTarget: withoutElementKey(step.dropTarget) } : {},
       pageUrl: toPath(step.pageUrl, origin),
       value: step.action === "goto" && step.value ? toPath(step.value, origin) : step.value
-    }))
+    })),
+    ...session.viewports?.length ? { viewports: session.viewports.map((v) => ({ ...v })) } : {}
   };
 }
 function withoutElementKey(target) {
@@ -1915,7 +1930,12 @@ function sessionFromSteps(doc, origin = doc.origin) {
     value: step.action === "goto" && step.value ? toAbsolute(step.value, origin) : step.value
   }));
   const firstGoto = steps.find((s) => s.action === "goto");
-  return { steps, startedAt: doc.recordedAt, startUrl: firstGoto?.value ?? steps[0]?.pageUrl ?? origin ?? "" };
+  return {
+    steps,
+    startedAt: doc.recordedAt,
+    startUrl: firstGoto?.value ?? steps[0]?.pageUrl ?? origin ?? "",
+    ...doc.viewports?.length ? { viewports: doc.viewports } : {}
+  };
 }
 function isObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -2001,6 +2021,44 @@ function checkAssertion(c, v, path19) {
     note: c.text(v.note, `${path19}.note`, STEPS_LIMITS.valueLength, true)
   };
 }
+function checkViewports(c, v, stepCount) {
+  if (v == null) return [];
+  if (!Array.isArray(v)) {
+    c.fail("viewports", "must be a list");
+    return [];
+  }
+  if (v.length > STEPS_LIMITS.viewports) {
+    c.fail("viewports", `holds more than ${STEPS_LIMITS.viewports}`);
+    return [];
+  }
+  const out = [];
+  v.forEach((entry, i) => {
+    const at = `viewports[${i}]`;
+    if (!isObject(entry)) return c.fail(at, "must be an object");
+    const { step, width, height } = entry;
+    if (!Number.isInteger(step) || step < 0 || step >= stepCount)
+      return c.fail(`${at}.step`, "must be the index of a step");
+    for (const [name, size] of [
+      ["width", width],
+      ["height", height]
+    ]) {
+      if (!Number.isInteger(size) || size < 1 || size > STEPS_LIMITS.viewportSize)
+        return c.fail(`${at}.${name}`, `must be a whole number of pixels from 1 to ${STEPS_LIMITS.viewportSize}`);
+    }
+    const { zoom } = entry;
+    if (zoom != null && (typeof zoom !== "number" || !(zoom >= STEPS_LIMITS.zoom.min && zoom <= STEPS_LIMITS.zoom.max)))
+      return c.fail(`${at}.zoom`, `must be a zoom factor from ${STEPS_LIMITS.zoom.min} to ${STEPS_LIMITS.zoom.max}`);
+    const last = out[out.length - 1];
+    if (last && last.step >= step) return c.fail(`${at}.step`, "must come after the step before it");
+    out.push({
+      step,
+      width,
+      height,
+      ...zoom != null && zoom !== 1 ? { zoom } : {}
+    });
+  });
+  return out;
+}
 function checkStep(c, v, path19) {
   if (!isObject(v)) {
     c.fail(path19, "must be an object");
@@ -2072,13 +2130,15 @@ function parseSteps(input) {
     const originText = c.text(value.origin, "origin", STEPS_LIMITS.textLength, true);
     const origin = originText ? originOf2(originText) : null;
     if (originText && !origin) c.fail("origin", "must be an http(s) origin");
+    const viewports = checkViewports(c, value.viewports, steps.length);
     doc = {
       v: STEPS_VERSION,
       title: c.text(value.title, "title", STEPS_LIMITS.textLength, true),
       origin,
       recordedAt: value.recordedAt == null ? 0 : c.number(value.recordedAt, "recordedAt"),
       note: c.text(value.note, "note", STEPS_LIMITS.valueLength, true),
-      steps
+      steps,
+      ...viewports.length > 0 ? { viewports } : {}
     };
   }
   return c.errors.length > 0 ? { ok: false, errors: c.errors } : { ok: true, steps: doc };
@@ -2454,6 +2514,8 @@ var DEFAULTS = {
   // Off by default: JavaScript coverage slows the page, so a scheduled job opts in.
   captureCodeReach: false,
   captureServerTraces: true,
+  captureResources: true,
+  leakCheck: "report",
   sampleAriaOnPass: true,
   uploadManifest: true,
   defaultCapture: true,
@@ -2494,6 +2556,8 @@ var PIWI_ENV_KEYS = {
   captureCodeReach: "PIWI_CAPTURE_CODE_REACH",
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
+  captureResources: "PIWI_CAPTURE_RESOURCES",
+  leakCheck: "PIWI_LEAK_CHECK",
   sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
   uploadManifest: "PIWI_UPLOAD_MANIFEST",
   defaultCapture: "PIWI_DEFAULT_CAPTURE",
@@ -2545,6 +2609,8 @@ var ENV_FALLBACK_SPECS = [
   { option: "capturePageInventory", env: PIWI_ENV_KEYS.capturePageInventory, kind: "bool" },
   { option: "captureCodeReach", env: PIWI_ENV_KEYS.captureCodeReach, kind: "bool" },
   { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
+  { option: "captureResources", env: PIWI_ENV_KEYS.captureResources, kind: "bool" },
+  { option: "leakCheck", env: PIWI_ENV_KEYS.leakCheck, kind: "string" },
   { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, kind: "bool" },
   { option: "uploadManifest", env: PIWI_ENV_KEYS.uploadManifest, kind: "bool" },
   { option: "defaultCapture", env: PIWI_ENV_KEYS.defaultCapture, kind: "bool" },
@@ -3404,6 +3470,10 @@ function formatGateResult(result) {
       `  ${facts.quarantinedFailures} failing ${facts.quarantinedFailures === 1 ? "test is" : "tests are"} quarantined and did not count`
     );
   }
+  if (facts.resources?.reported) {
+    const { leaks, newLeaks } = facts.resources;
+    lines.push(`  ${leaks.length} ${leaks.length === 1 ? "leak" : "leaks"}, ${newLeaks.length} new`);
+  }
   for (const violation of result.violations) lines.push(`  \u2716 ${violation.message}`);
   for (const warning of result.warnings ?? []) lines.push(`  \u26A0 ${warning}`);
   lines.push(`  ${facts.runUrl}`);
@@ -3439,6 +3509,8 @@ Policy (at least one is required):
   --fail-on-new-cluster    Fail when this run introduced a new failure cluster
   --fail-on-flaky          Fail when this run contains any flaky test
   --require-selection <key>  Fail when a test the named selection matches did not run or failed
+  --max-leaks <n>          Fail when the run left more than n browsers, contexts or pages open (per opening line)
+  --max-new-leaks <n>      Fail when more than n of those were never seen on the base branch
 
 Warn-only (reported, never fails the build):
   --max-uncovered-changes <n>  Warn when more than n changed files have no observed test reach
@@ -3495,7 +3567,9 @@ function parseGateArgs(argv, env) {
     maxQuarantined: readCount(argv, "--max-quarantined"),
     failOnNewCluster: argv.includes("--fail-on-new-cluster"),
     failOnFlaky: argv.includes("--fail-on-flaky"),
-    requireSelection: readOption4(argv, "--require-selection")
+    requireSelection: readOption4(argv, "--require-selection"),
+    maxLeaks: readCount(argv, "--max-leaks"),
+    maxNewLeaks: readCount(argv, "--max-new-leaks")
   };
   return {
     serverUrl,

package/dist/global-setup-module.js

@@ -83,6 +83,8 @@ var DEFAULTS = {
   // Off by default: JavaScript coverage slows the page, so a scheduled job opts in.
   captureCodeReach: false,
   captureServerTraces: true,
+  captureResources: true,
+  leakCheck: "report",
   sampleAriaOnPass: true,
   uploadManifest: true,
   defaultCapture: true,
@@ -123,6 +125,8 @@ var PIWI_ENV_KEYS = {
   captureCodeReach: "PIWI_CAPTURE_CODE_REACH",
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
+  captureResources: "PIWI_CAPTURE_RESOURCES",
+  leakCheck: "PIWI_LEAK_CHECK",
   sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
   uploadManifest: "PIWI_UPLOAD_MANIFEST",
   defaultCapture: "PIWI_DEFAULT_CAPTURE",
@@ -168,6 +172,8 @@ var ENV_FALLBACK_SPECS = [
   { option: "capturePageInventory", env: PIWI_ENV_KEYS.capturePageInventory, kind: "bool" },
   { option: "captureCodeReach", env: PIWI_ENV_KEYS.captureCodeReach, kind: "bool" },
   { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
+  { option: "captureResources", env: PIWI_ENV_KEYS.captureResources, kind: "bool" },
+  { option: "leakCheck", env: PIWI_ENV_KEYS.leakCheck, kind: "string" },
   { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, kind: "bool" },
   { option: "uploadManifest", env: PIWI_ENV_KEYS.uploadManifest, kind: "bool" },
   { option: "defaultCapture", env: PIWI_ENV_KEYS.defaultCapture, kind: "bool" },

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
 import { PlaywrightTestConfig, Locator, TestType, Page, Fixtures, PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions } from '@playwright/test';
 export { PlaywrightTestConfig } from '@playwright/test';
-export { PiwiFixtures, extendPiwiFixtures, piwiFixtures } from './internal/capture/capture-fixtures.js';
+export { PiwiFixtures, PiwiWorkerFixtures, extendPiwiFixtures, piwiFixtures } from './internal/capture/capture-fixtures.js';
 import '@piwitests/picker-dom';
 import '@piwitests/core/wire';
 import '@piwitests/core/code-reach';
@@ -100,6 +100,35 @@ interface PiwiDashboardOptions {
      * `false`. Can also be forced off with `PIWI_CAPTURE_SERVER_TRACES=false`.
      */
     captureServerTraces?: boolean;
+    /**
+     * Keep a ledger of the browsers, contexts, pages and API request contexts each
+     * test opens, and list at the end of the run the ones left open after the
+     * scope that created them ended (a context a test never closed, a `beforeAll`
+     * context no `afterAll` closes, a browser a test launched itself), the pages
+     * opened and never used, and the pages, listeners and route handlers piling up
+     * on a page or context that lives across tests. Each finding names the line or
+     * the fixture that opened the object. Rides the capture fixtures and costs a
+     * few bookkeeping steps per test. Also samples the run's processes and the
+     * machine, with or without the fixtures, and prints what the run cost: CPU by
+     * process, time spent waiting for a CPU, peak memory and disk. The findings,
+     * the run's cost and each test's go to the dashboard with the run, on its
+     * Resources tab. Defaults to `true`. Set to `false` (or
+     * `PIWI_CAPTURE_RESOURCES=false`) to turn both off.
+     */
+    captureResources?: boolean;
+    /**
+     * What the capture fixtures do when a test leaves open a browser, context,
+     * page or API request context that the test itself opened (its body or its
+     * `beforeEach`/`afterEach` hooks; a fixture's objects are the fixture's):
+     * `'report'` lists it in the end-of-run summary, `'fail'` also fails the test
+     * with the line that opened it, and `'close'` closes it when the test ends and
+     * still lists it. A `beforeAll` object left open is only ever reported. Each
+     * test is judged when it ends, so a test that hands what it opened to the next
+     * one fails under `'fail'` and loses it under `'close'`: open such objects in
+     * `beforeAll` and close them in `afterAll`. Defaults to `'report'`. Can also
+     * be set with `PIWI_LEAK_CHECK`.
+     */
+    leakCheck?: 'report' | 'fail' | 'close';
     /**
      * Sample the ARIA snapshot at the end of a *passing* test, so a later failure
      * can be diffed against the page as it last looked when green. Rate-limited by
@@ -375,6 +404,20 @@ declare class PiwiDashboardReporter {
     private filterDetails;
     /** Configured `maxFailures` (0 = unlimited) — disambiguates an interrupted run's unrun reason. */
     private maxFailures;
+    /** The resource censuses the capture fixtures attached, one per test attempt. */
+    private resourceCensuses;
+    /** Lifecycle steps of the tests that ran without the fixtures. */
+    private lifecycleTallies;
+    /** The user fixtures set up by the tests that left a page unused, by test id. */
+    private fixturesByTest;
+    /** The file workers append their shutdown census to, set in `onBegin`. */
+    private resourcesFile;
+    /** Samples the run's processes and the machine from `onBegin` to `onEnd`. */
+    private sampler;
+    /** Bytes of the files the tests attached, by kind. */
+    private artifactBytes;
+    /** The run's resource report for the dashboard, built in `onEnd`. */
+    private resourceReport;
     private httpClient;
     private uploader;
     private fileHandler;
@@ -408,6 +451,17 @@ declare class PiwiDashboardReporter {
     onStepEnd(test: TestCase | undefined, _result: TestResult | undefined, step: any): void;
     /** Playwright reporter hook: called when an individual test finishes */
     onTestEnd(test: TestCase, result: TestResult): void;
+    /**
+     * Add up the files a test attached, and keep its resource census; for a test
+     * that ran without the capture fixtures, tally the browsers and contexts its
+     * steps opened and closed.
+     */
+    private collectResources;
+    /**
+     * Print what the run left open or opened for nothing, from the censuses and
+     * the workers' shutdown file, then what the run cost the machine.
+     */
+    private reportResources;
     /**
      * Synthesize `didnotrun` cases for tests Playwright planned but never reported
      * (no `onTestEnd`) — typically because `maxFailures` cut the run short. These