@piwitests/reporter 0.41.0 → 0.43.0

package/dist/global-setup-module.js

@@ -90,6 +90,7 @@ var DEFAULTS = {
   streamingBatchSize: 5,
   streamingBatchDelay: 2e3,
   maxStreamBufferBytes: 100 * 1024 * 1024,
+  submitTimeout: 15 * 60 * 1e3,
   failOnFlakyTests: false,
   username: null,
   password: null,
@@ -111,6 +112,7 @@ var PIWI_ENV_KEYS = {
   streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE",
   streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY",
   maxStreamBufferBytes: "PIWI_MAX_STREAM_BUFFER_BYTES",
+  submitTimeout: "PIWI_SUBMIT_TIMEOUT",
   liveFileUploads: "PIWI_LIVE_FILE_UPLOADS",
   failOnFlakyTests: "PIWI_FAIL_ON_FLAKY_TESTS",
   uploadTraces: "PIWI_UPLOAD_TRACES",
@@ -137,6 +139,7 @@ var PIWI_ENV_KEYS = {
   aiScreenshotFallback: "PIWI_AI_SCREENSHOT_FALLBACK"
 };
 var PIWI_DESKTOP_CONFIG_ENV = "PIWI_DESKTOP_CONFIG";
+var PIWI_SHARD_ENV = "PIWI_SHARD";
 function readBool(val) {
   if (val === void 0) return void 0;
   return val === "true";
@@ -155,6 +158,7 @@ var ENV_FALLBACK_SPECS = [
   { option: "streamingBatchSize", env: PIWI_ENV_KEYS.streamingBatchSize, kind: "number" },
   { option: "streamingBatchDelay", env: PIWI_ENV_KEYS.streamingBatchDelay, kind: "number" },
   { option: "maxStreamBufferBytes", env: PIWI_ENV_KEYS.maxStreamBufferBytes, kind: "number" },
+  { option: "submitTimeout", env: PIWI_ENV_KEYS.submitTimeout, kind: "number" },
   { option: "liveFileUploads", env: PIWI_ENV_KEYS.liveFileUploads, kind: "bool" },
   { option: "failOnFlakyTests", env: PIWI_ENV_KEYS.failOnFlakyTests, kind: "bool" },
   { option: "uploadTraces", env: PIWI_ENV_KEYS.uploadTraces, kind: "bool" },
@@ -250,13 +254,17 @@ var HttpClient = class {
   /**
    * @param serverUrl Base URL of the Piwi Dashboard server (e.g. `http://localhost:3000`).
    * @param logger    Prefixed logger for verbose diagnostics.
-   * @param timeout   Socket inactivity timeout in ms (default 30s). A hung
-   *                  server now fails fast instead of stalling the reporter.
+   * @param timeout   Socket inactivity timeout in ms (default 30s), so a hung
+   *                  server fails fast rather than stalling the reporter.
    */
   constructor(serverUrl, logger = new Logger(), timeout = 3e4) {
     this.serverUrl = serverUrl;
     this.logger = logger;
     this.timeout = timeout;
+    /** Requests in flight, so `close` can abort them. */
+    this.inFlight = /* @__PURE__ */ new Set();
+    /** Set by `close`: every later request fails with this reason. */
+    this.closedReason = null;
     this.warnIfInsecureTransport();
   }
   /**
@@ -267,7 +275,7 @@ var HttpClient = class {
    * endpoint exposes the key and payloads on the wire. Loopback (localhost /
    * 127.0.0.1 / ::1) is exempt: that traffic never leaves the machine. This
    * warns rather than refuses so internal HTTP deployments (e.g. behind a VPN)
-   * still work, but the exposure is no longer silent.
+   * work, while the exposure is still reported.
    */
   warnIfInsecureTransport() {
     let url;
@@ -288,6 +296,16 @@ var HttpClient = class {
   get baseUrl() {
     return this.serverUrl;
   }
+  /** Whether `close` was called. */
+  get closed() {
+    return this.closedReason !== null;
+  }
+  /** Abort every request in flight and fail every later one with `reason`. */
+  close(reason) {
+    this.closedReason = reason;
+    for (const req of this.inFlight) req.destroy(new Error(reason));
+    this.inFlight.clear();
+  }
   /**
    * Resolve an auth credential: prefer `apiKey`, fall back to `username`/`password` login,
    * or return `null` when neither is configured.
@@ -408,6 +426,10 @@ var HttpClient = class {
   /** Unified request core: transport, headers, auth, response accumulation, timeout. */
   request(method, pathname, opts) {
     return new Promise((resolve2, reject) => {
+      if (this.closedReason !== null) {
+        reject(new Error(this.closedReason));
+        return;
+      }
       const url = new import_node_url.URL(pathname, this.serverUrl);
       const transport = url.protocol === "https:" ? https : http;
       const headers = { ...opts.headers };
@@ -436,11 +458,14 @@ var HttpClient = class {
           });
         }
       );
+      this.inFlight.add(req);
+      req.on("close", () => this.inFlight.delete(req));
       req.on("error", reject);
       req.setTimeout(this.timeout, () => {
         req.destroy(new Error(`Request to ${pathname} timed out after ${this.timeout}ms`));
       });
       if (opts.form) {
+        opts.form.on("error", (error) => req.destroy(error));
         opts.form.pipe(req);
       } else if (opts.body !== void 0) {
         req.write(opts.body);
@@ -472,22 +497,44 @@ function computeInstanceId(projectName, runLabel) {
 }
 
 // src/internal/support/ci.ts
-function detectCiRunLabel() {
-  const env = process.env;
-  if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID) return env.GITHUB_RUN_ID;
-  if (env.GITLAB_CI && env.CI_PIPELINE_ID) return env.CI_PIPELINE_ID;
-  if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID) return env.CIRCLE_WORKFLOW_ID;
-  if (env.TRAVIS && env.TRAVIS_BUILD_ID) return env.TRAVIS_BUILD_ID;
-  if (env.TF_BUILD && env.BUILD_BUILDID) return env.BUILD_BUILDID;
-  if (env.JENKINS_URL && env.BUILD_ID) return env.BUILD_ID;
-  if (env.BUILDKITE_BUILD_ID) return env.BUILDKITE_BUILD_ID;
-  if (env.TEAMCITY_BUILD_ID) return env.TEAMCITY_BUILD_ID;
-  if (env.BITBUCKET_BUILD_NUMBER) return env.BITBUCKET_BUILD_NUMBER;
-  if (env.SEMAPHORE_WORKFLOW_ID) return env.SEMAPHORE_WORKFLOW_ID;
-  if (env.APPVEYOR_BUILD_ID) return env.APPVEYOR_BUILD_ID;
-  if (env.DRONE_BUILD_NUMBER) return env.DRONE_BUILD_NUMBER;
+function detectCiIds(env) {
+  if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID) {
+    const run = env.GITHUB_RUN_ATTEMPT ? `${env.GITHUB_RUN_ID}-${env.GITHUB_RUN_ATTEMPT}` : env.GITHUB_RUN_ID;
+    return { run, job: env.GITHUB_JOB || null };
+  }
+  if (env.GITLAB_CI && env.CI_PIPELINE_ID) return { run: env.CI_PIPELINE_ID, job: env.CI_JOB_ID || null };
+  if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID) return { run: env.CIRCLE_WORKFLOW_ID, job: env.CIRCLE_BUILD_NUM || null };
+  if (env.TRAVIS && env.TRAVIS_BUILD_ID) return { run: env.TRAVIS_BUILD_ID, job: env.TRAVIS_JOB_ID || null };
+  if (env.TF_BUILD && env.BUILD_BUILDID) return { run: env.BUILD_BUILDID, job: env.SYSTEM_JOBID || null };
+  if (env.JENKINS_URL && env.BUILD_ID) return { run: env.BUILD_ID, job: null };
+  if (env.BUILDKITE_BUILD_ID) return { run: env.BUILDKITE_BUILD_ID, job: env.BUILDKITE_JOB_ID || null };
+  if (env.TEAMCITY_BUILD_ID) return { run: env.TEAMCITY_BUILD_ID, job: null };
+  if (env.BITBUCKET_BUILD_NUMBER) return { run: env.BITBUCKET_BUILD_NUMBER, job: env.BITBUCKET_STEP_UUID || null };
+  if (env.SEMAPHORE_WORKFLOW_ID) return { run: env.SEMAPHORE_WORKFLOW_ID, job: env.SEMAPHORE_JOB_ID || null };
+  if (env.APPVEYOR_BUILD_ID) return { run: env.APPVEYOR_BUILD_ID, job: env.APPVEYOR_JOB_ID || null };
+  if (env.DRONE_BUILD_NUMBER) return { run: env.DRONE_BUILD_NUMBER, job: null };
   return null;
 }
+function resolveRunLabel(configured, sharded) {
+  if (configured) return configured;
+  const ci = detectCiIds(process.env);
+  if (!ci) return null;
+  return !sharded && ci.job ? `${ci.run}|${ci.job}` : ci.run;
+}
+
+// src/internal/support/shard-info.ts
+function parseShardSpec(raw) {
+  const match = raw?.trim().match(/^(\d+)\s*\/\s*(\d+)$/);
+  if (!match) return null;
+  const current = Number(match[1]);
+  const total = Number(match[2]);
+  return current >= 1 && current <= total && total > 1 ? { current, total } : null;
+}
+function resolveShardInfo(config, env = process.env) {
+  const pwShard = config.shard;
+  if (pwShard && pwShard.total > 1) return { current: pwShard.current, total: pwShard.total };
+  return parseShardSpec(env[PIWI_SHARD_ENV]);
+}
 
 // src/internal/collect/metadata-collector.ts
 var import_node_child_process = require("child_process");
@@ -687,10 +734,7 @@ function createGlobalSetup(options, userSetup) {
     const httpClient = new HttpClient(opts.serverUrl, logger);
     try {
       const auth = await httpClient.resolveAuth(opts);
-      const runLabel = opts.runLabel || detectCiRunLabel();
-      const pwShard = config.shard;
-      const shardIndex = pwShard?.current;
-      const shardTotal = pwShard?.total;
+      const shard = resolveShardInfo(config);
       const response = await httpClient.postJSON(
         "/api/test-runs/setup",
         {
@@ -700,9 +744,9 @@ function createGlobalSetup(options, userSetup) {
           label: opts.label || null,
           keep: opts.keep === true,
           startTime: (/* @__PURE__ */ new Date()).toISOString(),
-          instanceId: computeInstanceId(opts.projectName, runLabel),
-          shardIndex,
-          shardTotal
+          instanceId: computeInstanceId(opts.projectName, resolveRunLabel(opts.runLabel, shard !== null)),
+          shardIndex: shard?.current,
+          shardTotal: shard?.total
         },
         auth
       );

package/dist/index.d.ts

@@ -22,6 +22,15 @@ interface PiwiDashboardOptions {
     projectName?: string;
     /** Optional description of the project */
     projectDescription?: string;
+    /**
+     * Time budget (ms) for the reporter's end-of-run work: delivering the last
+     * live events, uploading the remaining traces and attachments, and submitting
+     * the run. When it runs out, the reporter stops waiting for the dashboard and
+     * saves the run's results locally; the next run for the project uploads them,
+     * without traces or attachments. Defaults to `900000` (15 minutes). Set to `0`
+     * for no limit. Can also be set with `PIWI_SUBMIT_TIMEOUT`.
+     */
+    submitTimeout?: number;
     /** Upload trace files to the dashboard. Defaults to `true`. */
     uploadTraces?: boolean;
     /** Upload the Playwright HTML report. Defaults to `true`. */
@@ -189,7 +198,12 @@ interface PiwiDashboardOptions {
         dir?: string;
         label?: string;
     }>;
-    /** Stable label that ties shards together (e.g. CI run ID). Auto-detected from CI env; override if needed. */
+    /**
+     * Stable label that ties shards together (e.g. CI run ID). Auto-detected from
+     * CI env, with the CI job's id added for a run that is not sharded; a label
+     * set here is used as it is. Override it when your CI is not detected, or to
+     * keep matrix legs that report to one project apart.
+     */
     runLabel?: string;
     /** Deployment environment for this run, e.g. `"production"`, `"staging"`, `"integration"` */
     environment?: string;
@@ -303,9 +317,8 @@ declare function createGlobalSetup(options?: PiwiDashboardOptions, userSetup?: (
  * executed after it.
  *
  * Playwright options required in `globalSetup` are forwarded via `PIWI_*`
- * environment variables (see `applyOptionsToEnv` in `config.ts` for the
- * supported set — `serverUrl`, `projectName`, `verbose`, `apiKey`,
- * `username`, `password`, `environment`, `label`, `runLabel`).
+ * environment variables (see `applyOptionsToEnv` in `internal/config/env.ts`
+ * for the supported set).
  *
  * The top-level `use` block's `screenshot` and `trace` are defaulted to
  * `'only-on-failure'` / `'retain-on-failure'` when unset so failure evidence is
@@ -345,8 +358,8 @@ declare class PiwiDashboardReporter {
     private reportedTestIds;
     /** Per-test attempt history, keyed by `test.id`; snapshotted onto every attempt's payload. */
     private attemptsByTest;
+    /** Derived in `onBegin`, once the shard is known. */
     private instanceId;
-    private runLabel;
     private shardInfo;
     private metadata;
     private enabled;