@qualflare/cucumberjs 0.4.0 → 0.5.0

package/README.md

@@ -5,7 +5,7 @@
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](./LICENSE)
 
 A native CucumberJS reporter for [Qualflare](https://qualflare.com) — captures test results directly
-from your `cucumber-js` run: Feature/Scenario status, real retry counts, screenshots, videos,
+from your `cucumber-js` run: Feature/Scenario status, per-attempt retry history, screenshots, videos,
 Given/When/Then step traces, Scenario Outline rows, and author-facing metadata (labels, links, tags,
 custom attachments).
 
@@ -125,6 +125,21 @@ wrong value cannot fail at run time — this package makes no network calls —
   (workaround, not a first-class rendering).
 - **`BeforeStep`/`AfterStep` hooks are off by default** (`includeStepHooks`) — noisy for suites with
   global per-step instrumentation.
+- **`BeforeAll`/`AfterAll` attachments need the hook to fail** — a failed global hook becomes a
+  synthetic Case and its attachments land there; a passing one produces no Case, so they are
+  dropped.
+- **`parameter()` outside a step is not masked** — `masked` is a display hint for the UI; the
+  server never redacts the value, so never put a real secret in one. See
+  [`docs/LIMITATIONS.md`](./docs/LIMITATIONS.md#qualflareparameter-outside-a-step-has-no-masking).
+- **Attachment caps are two budgets, not one pool** — `maxAttachmentBytes` bounds a single
+  attachment and `maxTotalAttachmentBytes` the whole run; anything over either is dropped
+  outright rather than truncated. Raising them is the easiest way to push a request past
+  `/collect`'s body limit. See
+  [`docs/LIMITATIONS.md`](./docs/LIMITATIONS.md#per-caseper-attachment-caps-are-independent-not-pooled).
+- **Retries carry per-attempt errors, but everything else is the final attempt** — `Case.attempts`
+  records each attempt's status, duration and error; steps, labels, links, tags, priority,
+  properties and attachments come from the last attempt only, so an abandoned attempt's step trace
+  is discarded rather than replayed alongside the final one.
 
 Full details in [`docs/LIMITATIONS.md`](./docs/LIMITATIONS.md).
 

package/dist/formatter/index.cjs

@@ -1038,7 +1038,7 @@ function timestampMs(ts) {
 var os = __toESM(require("os"), 1);
 
 // src/config/version.ts
-var PACKAGE_VERSION = "0.4.0";
+var PACKAGE_VERSION = "0.5.0";
 
 // src/formatter/collect-builder.ts
 function resolveOs(config) {
@@ -1165,23 +1165,52 @@ function buildHookIndex(supportCodeLibrary) {
 
 // src/formatter/run-hook-tracker.ts
 var RunHookTracker = class {
+  constructor(config, budget) {
+    this.config = config;
+    this.budget = budget;
+  }
+  config;
+  budget;
   /** `testRunHookStartedId` -> the hook it started, so `finish()` can look
    * up its kind/name. `TestRunHookFinished.result.duration` already gives
    * an accurate duration directly — no start/finish timestamp delta needed. */
   started = /* @__PURE__ */ new Map();
   failed = [];
+  /** `testRunHookStartedId` -> attachments made during that hook, unresolved. */
+  pending = /* @__PURE__ */ new Map();
   start(e) {
     this.started.set(e.id, e.hookId);
   }
+  /**
+   * Buffers one attachment made from inside a `BeforeAll`/`AfterAll`. Returns
+   * whether it was claimed, so the caller can tell a run-hook attachment from
+   * one that simply has no home.
+   *
+   * `testRunHookStartedId` is optional in the message schema and only populated
+   * by newer cucumber-js; when it is absent this returns false and the
+   * attachment is dropped exactly as it was before.
+   */
+  attachment(e) {
+    if (!e.testRunHookStartedId) {
+      return false;
+    }
+    const content = e.contentEncoding === "BASE64" ? e.body : Buffer.from(e.body, "utf8").toString("base64");
+    const list = this.pending.get(e.testRunHookStartedId) ?? [];
+    list.push({ name: e.fileName || "attachment", mimeType: e.mediaType, content });
+    this.pending.set(e.testRunHookStartedId, list);
+    return true;
+  }
   finish(e, hookIndex) {
     const hookId = this.started.get(e.testRunHookStartedId);
     this.started.delete(e.testRunHookStartedId);
     const status = mapStatus(e.result.status);
     if (status === "passed" || status === "skipped") {
+      this.pending.delete(e.testRunHookStartedId);
       return;
     }
     const hook = hookId ? hookIndex.get(hookId) : void 0;
     const label = hook?.kind === "afterAll" ? "AfterAll hook" : "BeforeAll hook";
+    const attachments = this.takeAttachments(e.testRunHookStartedId);
     this.failed.push({
       id: `global-hook:${e.testRunHookStartedId}`,
       name: hook?.name || label,
@@ -1190,9 +1219,17 @@ var RunHookTracker = class {
       // `result.message` first — see `step-mapper.ts`'s `formatError()` doc
       // comment for why (verified empirically to be the version-safe field
       // across the peer-dependency range; `exception.stackTrace` is not).
-      error: e.result.message || e.result.exception?.stackTrace || e.result.exception?.message
+      error: e.result.message || e.result.exception?.stackTrace || e.result.exception?.message,
+      ...attachments.length > 0 ? { attachments } : {}
     });
   }
+  /** Resolves and clears the buffer for one hook. Called only for a FAILED
+   * hook, so the budget is never spent on a passing one's attachments. */
+  takeAttachments(testRunHookStartedId) {
+    const buffered = this.pending.get(testRunHookStartedId) ?? [];
+    this.pending.delete(testRunHookStartedId);
+    return buffered.map((pending) => resolvePendingAttachment(pending, this.config, this.budget)).filter((a) => a !== void 0);
+  }
   /** Returns `undefined` if no run-hook failed — see the class doc comment
    * for why a passing BeforeAll/AfterAll produces no Case at all. */
   buildSuite() {
@@ -1264,7 +1301,7 @@ var QualflareCucumberFormatter = class extends import_cucumber.Formatter {
   testCaseIndex = /* @__PURE__ */ new Map();
   attachmentBudget;
   attemptTracker;
-  runHookTracker = new RunHookTracker();
+  runHookTracker;
   finishedCases = [];
   /** One promise per `testCaseFinished` envelope, resolving once that
    * scenario's `AttemptTracker.finish()` (which itself awaits any pending
@@ -1279,6 +1316,7 @@ var QualflareCucumberFormatter = class extends import_cucumber.Formatter {
     this.config = resolveConfig(options.parsedArgvOptions);
     this.hookIndex = buildHookIndex(options.supportCodeLibrary);
     this.attachmentBudget = new AttachmentBudget(this.config.maxTotalAttachmentBytes);
+    this.runHookTracker = new RunHookTracker(this.config, this.attachmentBudget);
     this.attemptTracker = new AttemptTracker(
       this.hookIndex,
       this.gherkin,