@qualflare/cucumberjs 0.3.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

@@ -48,6 +48,8 @@ var RESERVED_MESSAGE_MEDIA_TYPE = "application/vnd.qualflare.message+json";
 var MAX_SUITES_PER_LAUNCH = 2e3;
 var MAX_CASES_PER_SUITE = 5e3;
 var MAX_TAGS_PER_CASE = 64;
+var MAX_ATTEMPTS_PER_CASE = 50;
+var MAX_ATTEMPT_MESSAGE_RUNES = 8192;
 var MAX_VIDEO_UPLOAD_BYTES = 50 * 1024 * 1024;
 var MAX_STEPS_PER_TEST_ATTEMPT = 300;
 
@@ -526,6 +528,18 @@ function messageDurationToNs(duration) {
   return total > 0 ? Math.round(total) : 0;
 }
 
+// src/shared/text.ts
+function truncateRunes(value, maxRunes) {
+  if (value.length <= maxRunes) {
+    return value;
+  }
+  const runes = Array.from(value);
+  if (runes.length <= maxRunes) {
+    return value;
+  }
+  return runes.slice(0, maxRunes).join("");
+}
+
 // src/formatter/case-builder.ts
 function combineSteps(realSteps, manualSteps) {
   if (realSteps.length === 0 && manualSteps.length === 0) {
@@ -544,6 +558,26 @@ function combineSteps(realSteps, manualSteps) {
   });
   return [...realSteps, ...offsetManual];
 }
+function buildAttempts(attempts) {
+  if (attempts.length < 2) {
+    return void 0;
+  }
+  let kept = attempts;
+  if (attempts.length > MAX_ATTEMPTS_PER_CASE) {
+    kept = [...attempts.slice(0, MAX_ATTEMPTS_PER_CASE - 1), attempts[attempts.length - 1]];
+  }
+  return kept.map((a, i) => {
+    const attempt = {
+      attempt: i + 1,
+      status: a.status,
+      duration: a.duration
+    };
+    if (a.error) {
+      attempt.message = truncateRunes(a.error, MAX_ATTEMPT_MESSAGE_RUNES);
+    }
+    return attempt;
+  });
+}
 function collapseAttempts(attempts) {
   if (attempts.length === 0) {
     throw new Error("collapseAttempts: at least one attempt is required");
@@ -552,11 +586,13 @@ function collapseAttempts(attempts) {
   const retryCount = attempts.length - 1;
   const isFlaky = retryCount > 0 && final.status === "passed" && attempts.some((a) => a.status !== "passed");
   const duration = attempts.reduce((sum, a) => sum + a.duration, 0);
+  const attemptHistory = buildAttempts(attempts);
   return {
     status: final.status,
     duration,
     retryCount,
     isFlaky,
+    ...attemptHistory ? { attempts: attemptHistory } : {},
     error: final.status === "passed" ? void 0 : final.error,
     steps: combineSteps(final.steps, final.manualSteps),
     labels: final.labels,
@@ -596,6 +632,7 @@ function buildCase(uri, pickle, collapsed, gherkin) {
     duration: collapsed.duration,
     retryCount: collapsed.retryCount || void 0,
     isFlaky: collapsed.isFlaky || void 0,
+    attempts: collapsed.attempts,
     error: collapsed.error,
     tags: tags.length > 0 ? tags : void 0,
     steps: collapsed.steps,
@@ -1001,7 +1038,7 @@ function timestampMs(ts) {
 var os = __toESM(require("os"), 1);
 
 // src/config/version.ts
-var PACKAGE_VERSION = "0.3.0";
+var PACKAGE_VERSION = "0.5.0";
 
 // src/formatter/collect-builder.ts
 function resolveOs(config) {
@@ -1128,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,
@@ -1153,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() {
@@ -1227,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
@@ -1242,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,