@piwitests/reporter 0.60.0 → 0.61.0

package/dist/cli/index.js

@@ -932,6 +932,7 @@ var PIWI_ENV_KEYS = {
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   coverageBrowser: "PIWI_COVERAGE_BROWSER",
   coverageServer: "PIWI_COVERAGE_SERVER",
+  coverageCss: "PIWI_COVERAGE_CSS",
   externalIdPattern: "PIWI_EXTERNAL_ID_PATTERN",
   externalIdOnDuplicate: "PIWI_EXTERNAL_ID_ON_DUPLICATE",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
@@ -2320,6 +2321,8 @@ var STEPS_LIMITS = {
   /** Titles, names, texts, locators. */
   textLength: 500,
   viewports: 50,
+  /** The options a manual step's instruction names. */
+  options: 50,
   /** The widest and tallest viewport, in CSS pixels. */
   viewportSize: 1e4,
   /** The browser's zoom factors a viewport may name, as browsers allow them. */
@@ -2491,12 +2494,71 @@ function checkManual(c, v, path25) {
   }
   const description = c.text(v.description, `${path25}.description`, STEPS_LIMITS.valueLength, false);
   if (description != null && !description.trim()) c.fail(`${path25}.description`, "must not be empty");
+  const instruction = readInstruction(v.instruction);
   return {
     description: description ?? "",
     location: c.text(v.location, `${path25}.location`, STEPS_LIMITS.textLength, true),
-    call: c.text(v.call, `${path25}.call`, STEPS_LIMITS.textLength, true)
+    call: c.text(v.call, `${path25}.call`, STEPS_LIMITS.textLength, true),
+    ...instruction ? { instruction } : {}
   };
 }
+var isText = (v) => typeof v === "string" && v.length <= STEPS_LIMITS.valueLength;
+var isTextOrNull = (v) => v == null || isText(v);
+var isCount = (v) => Number.isInteger(v) && v >= 0;
+var INSTRUCTION_FIELDS = {
+  locator: isText,
+  call: isText,
+  matcher: isText,
+  what: isText,
+  expected: isTextOrNull,
+  received: isTextOrNull,
+  x: (v) => typeof v === "number" && Number.isFinite(v),
+  y: (v) => typeof v === "number" && Number.isFinite(v),
+  count: isCount,
+  limit: isCount,
+  options: (v) => Array.isArray(v) && v.length > 0 && v.length <= STEPS_LIMITS.options && v.every((o) => isText(o) || isCount(o))
+};
+var CHECK_VALUES = ["expected", "received"];
+var INSTRUCTION_KINDS = {
+  goBack: [],
+  goForward: [],
+  reload: [],
+  gotoUnknown: [],
+  setContent: [],
+  keyboardType: [],
+  mouseAt: ["x", "y", "call"],
+  mouseOrKeyboard: ["call"],
+  failedCall: ["call"],
+  locatorCall: ["locator", "call"],
+  fillUnknown: ["locator"],
+  fillPartial: ["locator"],
+  pressUnknown: ["locator"],
+  selectOptionUnknown: ["locator"],
+  setInputFiles: ["locator"],
+  dragTo: ["locator"],
+  drop: ["locator"],
+  focus: ["locator"],
+  blur: ["locator"],
+  dispatchEvent: ["locator"],
+  scrollIntoViewIfNeeded: ["locator"],
+  selectOptions: ["locator", "options"],
+  expectPoll: ["matcher", ...CHECK_VALUES],
+  expectValue: ["what", ...CHECK_VALUES],
+  expectLocator: ["locator", "matcher", ...CHECK_VALUES],
+  expectURL: CHECK_VALUES,
+  leadingSteps: ["count", "limit"]
+};
+function readInstruction(v) {
+  if (!isObject(v) || typeof v.kind !== "string" || !Object.prototype.hasOwnProperty.call(INSTRUCTION_KINDS, v.kind))
+    return null;
+  const kind = v.kind;
+  const out = { kind };
+  for (const field of INSTRUCTION_KINDS[kind]) {
+    if (!INSTRUCTION_FIELDS[field](v[field])) return null;
+    out[field] = v[field] ?? null;
+  }
+  return out;
+}
 function checkViewports(c, v, stepCount) {
   if (v == null) return [];
   if (!Array.isArray(v)) {
@@ -6308,7 +6370,7 @@ function attributeMatches(value, exact, actual) {
 
 // ../core/src/locator-break.ts
 var TEXT_KINDS = /* @__PURE__ */ new Set(["text", "translation", "literal"]);
-function isText(anchor) {
+function isText2(anchor) {
   return TEXT_KINDS.has(anchor.kind);
 }
 function hasAttribute(anchor, names) {
@@ -6407,7 +6469,7 @@ function directSlots(call, testIds) {
   const hasTextSlot = (index) => {
     const hasText = optionsOf(call.args[index]).get("hasText");
     if (!hasText) return null;
-    return stringSlot(hasText, false, "text", isText, (next) => withOption(call, index, "hasText", next));
+    return stringSlot(hasText, false, "text", isText2, (next) => withOption(call, index, "hasText", next));
   };
   const textOr = (attribute) => (a) => a.kind === "translation" || a.kind === "literal" || hasAttribute(a, [attribute]);
   switch (call.method) {
@@ -6420,16 +6482,16 @@ function directSlots(call, testIds) {
           opts.get("name"),
           exact,
           "name",
-          (a) => isText(a) || hasAttribute(a, ["aria-label", "title", "alt", "value"]),
+          (a) => isText2(a) || hasAttribute(a, ["aria-label", "title", "alt", "value"]),
           (next) => withOption(call, 1, "name", next)
         )
       );
       break;
     case "getByText":
-      slots.push(argSlot("text", isText));
+      slots.push(argSlot("text", isText2));
       break;
     case "getByLabel":
-      slots.push(argSlot("text", (a) => isText(a) || hasAttribute(a, ["aria-label"])));
+      slots.push(argSlot("text", (a) => isText2(a) || hasAttribute(a, ["aria-label"])));
       break;
     case "getByPlaceholder":
       slots.push(argSlot("text", textOr("placeholder")));

package/dist/global-setup-module.js

@@ -202,6 +202,7 @@ var PIWI_ENV_KEYS = {
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   coverageBrowser: "PIWI_COVERAGE_BROWSER",
   coverageServer: "PIWI_COVERAGE_SERVER",
+  coverageCss: "PIWI_COVERAGE_CSS",
   externalIdPattern: "PIWI_EXTERNAL_ID_PATTERN",
   externalIdOnDuplicate: "PIWI_EXTERNAL_ID_ON_DUPLICATE",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
@@ -321,10 +322,14 @@ function resolveOptions(raw, configDir) {
   const coverage = { ...mergedRaw.coverage };
   const coverageBrowser = env[PIWI_ENV_KEYS.coverageBrowser];
   const coverageServer = env[PIWI_ENV_KEYS.coverageServer];
+  const coverageCss = env[PIWI_ENV_KEYS.coverageCss];
   if (coverage.browser === void 0 && coverageBrowser)
     coverage.browser = coverageBrowser;
   if (coverage.server === void 0 && coverageServer) coverage.server = coverageServer;
-  if (coverage.browser !== void 0 || coverage.server !== void 0) mergedRaw.coverage = coverage;
+  if (coverage.css === void 0 && coverageCss) coverage.css = coverageCss;
+  if (coverage.browser !== void 0 || coverage.server !== void 0 || coverage.css !== void 0) {
+    mergedRaw.coverage = coverage;
+  }
   const externalId = { ...mergedRaw.externalId };
   const externalIdPattern = env[PIWI_ENV_KEYS.externalIdPattern];
   const externalIdOnDuplicate = env[PIWI_ENV_KEYS.externalIdOnDuplicate];
@@ -736,6 +741,7 @@ function isListMode(argv = process.argv) {
 }
 
 // src/internal/support/base-url-check.ts
+var net = __toESM(require("net"));
 var BASE_URL_CHECK_ATTEMPTS = 3;
 var BASE_URL_CHECK_TIMEOUT_MS = 1e4;
 var BASE_URL_CHECK_DELAY_MS = 2e3;
@@ -757,9 +763,9 @@ function cliProjectNames(argv = process.argv) {
   }
   return names;
 }
-function wildcard(pattern) {
+function wildcard(pattern, flags = "i") {
   const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  return new RegExp(`^${escaped.join(".*")}$`, "i");
+  return new RegExp(`^${escaped.join(".*")}$`, flags);
 }
 function selectedProjects(projects, argv = process.argv, filtered) {
   let chosen;
@@ -769,7 +775,7 @@ function selectedProjects(projects, argv = process.argv, filtered) {
   } else {
     const names = cliProjectNames(argv);
     if (!names || names.length === 0) return projects;
-    const patterns = names.map(wildcard);
+    const patterns = names.map((name) => wildcard(name));
     chosen = new Set(projects.filter((p) => patterns.some((re) => re.test(p.name ?? ""))));
   }
   if (!argv.includes("--no-deps")) {
@@ -791,23 +797,58 @@ function asProxy(value) {
   const proxy = value;
   return proxy && typeof proxy === "object" && typeof proxy.server === "string" ? proxy : void 0;
 }
-function baseUrlTargets(config, argv = process.argv) {
+function exposeNetworkCovers(rule, url) {
+  if (!rule) return false;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  const host = parsed.hostname;
+  const port = parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
+  return rule.split(",").some((token) => {
+    const match = token.match(/^(.*?)(?::(\d+))?$/);
+    if (!match) return false;
+    if (match[2] !== void 0 && Number(match[2]) !== port) return false;
+    const tokenHost = match[1];
+    if (tokenHost === "<loopback>") {
+      return host === "localhost" || host.endsWith(".localhost") || host === "127.0.0.1" || host === "[::1]";
+    }
+    if (tokenHost === "*") return true;
+    if (net.isIP(tokenHost)) return host === tokenHost;
+    if (net.isIP(host)) return false;
+    return wildcard(tokenHost.startsWith(".") ? `*${tokenHost}` : tokenHost, "").test(host);
+  });
+}
+function reachedRemotely(use, url, env) {
+  if (use?.connectOptions === void 0) {
+    return !!env.PW_TEST_CONNECT_WS_ENDPOINT && !exposeNetworkCovers(env.PW_TEST_CONNECT_EXPOSE_NETWORK, url);
+  }
+  const connect = use.connectOptions;
+  if (!connect || typeof connect !== "object" || typeof connect.wsEndpoint !== "string") return false;
+  return !exposeNetworkCovers(typeof connect.exposeNetwork === "string" ? connect.exposeNetwork : void 0, url);
+}
+function baseUrlTargets(config, argv = process.argv, env = process.env) {
   const projects = config.projects?.length ? config.projects : [{ name: "", use: config.use }];
   const filtered = config.projects?.length ? config.filteredProjects : void 0;
   const targets = /* @__PURE__ */ new Map();
   for (const project of selectedProjects(projects, argv, filtered)) {
     const url = project.use?.baseURL;
     if (typeof url !== "string" || !/^https?:\/\//i.test(url)) continue;
+    const remoteBrowser = reachedRemotely(project.use, url, env);
     const target = targets.get(url);
     if (target) {
       if (project.name) target.projects.push(project.name);
+      target.remoteBrowser ||= remoteBrowser;
       continue;
     }
     targets.set(url, {
       url,
       projects: project.name ? [project.name] : [],
       ignoreHTTPSErrors: project.use?.ignoreHTTPSErrors === true,
-      proxy: asProxy(project.use?.proxy)
+      proxy: asProxy(project.use?.proxy),
+      remoteBrowser
     });
   }
   return [...targets.values()];
@@ -848,14 +889,21 @@ async function checkBaseUrl(target, options = {}) {
   }
   return `${reason} (${attempts} ${attempts === 1 ? "attempt" : "attempts"})`;
 }
+function remoteBrowserNote(target) {
+  if (!target.remoteBrowser) return null;
+  const { host } = new URL(target.url);
+  return `The check ran from this machine's network, but a project's remote browser reaches ${host} from its own, since its exposeNetwork rule does not cover that address.`;
+}
 async function checkBaseUrls(config, options = {}) {
-  const targets = baseUrlTargets(config, options.argv);
+  const targets = baseUrlTargets(config, options.argv, options.env);
   const reasons = await Promise.all(targets.map((target) => checkBaseUrl(target, options)));
   const down = targets.flatMap((target, i) => reasons[i] ? [{ target, reason: reasons[i] }] : []);
   if (down.length === 0) return targets;
   const lines = down.map(({ target, reason }) => {
     const used = target.projects.length > 0 ? ` (${target.projects.join(", ")})` : "";
-    return `  ${target.url}${used}: ${reason}`;
+    const note = remoteBrowserNote(target);
+    return `  ${target.url}${used}: ${reason}${note ? `
+    ${note}` : ""}`;
   });
   const message = [
     `[Piwi Dashboard] The app under test did not answer, so no test ran:`,
@@ -1008,7 +1056,16 @@ function createGlobalSetup(options, userSetup) {
     }
     if (opts.checkBaseUrl === true) {
       const checked = await checkBaseUrls(config ?? {});
-      for (const target of checked) logger.debug(`Base URL answered: ${target.url}`);
+      for (const target of checked) {
+        const note = remoteBrowserNote(target);
+        if (note) {
+          logger.info(
+            `Base URL answered: ${target.url}. ${note} A navigation failure from that browser can mean its machine cannot reach the app, not that the app is down.`
+          );
+        } else {
+          logger.debug(`Base URL answered: ${target.url}`);
+        }
+      }
     }
     if (opts.enabled === false || !opts.serverUrl) {
       logger.info("Not enabled \u2014 set PIWI_DASHBOARD_URL or serverUrl to enable.");

package/dist/index.d.ts

@@ -140,6 +140,19 @@ interface PiwiDashboardOptions {
          * `PIWI_COVERAGE_SERVER`.
          */
         server?: 'off' | 'files' | 'functions' | 'lines';
+        /**
+         * What the browser's style sheets record: `'rules'`, the rules that
+         * matched an element during each test, from Chromium's CSS rule usage, each
+         * as its first and last line in the application's style sheet (a `.css`
+         * file served as written, a Vite dev server's styles, or a sheet with a
+         * source map), sent where a script's functions are; `'off'` records
+         * nothing. A change to a rule then selects the tests that rendered it. It
+         * costs style recalculation time, a little on most pages and up to half
+         * the test's time on a page with large style sheets and frequent
+         * re-renders, so it is a choice of its own. Chromium only. Defaults to
+         * `'off'`. Can also be set with `PIWI_COVERAGE_CSS`.
+         */
+        css?: 'off' | 'rules';
     };
     /**
      * Match each test to its history on the dashboard by an external ID, the ID the test has in your own test
@@ -256,8 +269,11 @@ interface PiwiDashboardOptions {
      * `globalSetup`, so leave it off when that setup is what starts the app. Only
      * the projects the run selects are checked, with their dependencies: the ones
      * `--project` names, or every project but those declared `default: false`
-     * (Playwright 1.64+). **Defaults to `false`**. Can
-     * also be set with `PIWI_CHECK_BASE_URL=true`.
+     * (Playwright 1.64+). The check runs from this machine's network: for a
+     * project whose browser runs on another machine (`connectOptions`) and whose
+     * `exposeNetwork` rule does not cover the base URL's host and port, its message says
+     * so, since that browser reaches the app from its own network. **Defaults to
+     * `false`**. Can also be set with `PIWI_CHECK_BASE_URL=true`.
      */
     checkBaseUrl?: boolean;
     /**
@@ -525,6 +541,8 @@ declare class PiwiDashboardReporter {
     private resourcesFile;
     /** Samples the run's processes and the machine from `onBegin` to `onEnd`. */
     private sampler;
+    /** Posts what the sampler and the censuses add while someone has the run open on the dashboard. */
+    private liveResources;
     /** Bytes of the files the tests attached, by kind. */
     private artifactBytes;
     /** The run's resource report for the dashboard, built in `onEnd`. */