@qualflare/cucumberjs 0.3.0 → 0.5.0

package/dist/formatter/index.js

@@ -12,6 +12,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;
 
@@ -492,6 +494,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) {
@@ -510,6 +524,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");
@@ -518,11 +552,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,
@@ -562,6 +598,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,
@@ -967,7 +1004,7 @@ function timestampMs(ts) {
 import * as os from "os";
 
 // src/config/version.ts
-var PACKAGE_VERSION = "0.3.0";
+var PACKAGE_VERSION = "0.5.0";
 
 // src/formatter/collect-builder.ts
 function resolveOs(config) {
@@ -1094,23 +1131,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,
@@ -1119,9 +1185,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() {
@@ -1193,7 +1267,7 @@ var QualflareCucumberFormatter = class extends 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
@@ -1208,6 +1282,7 @@ var QualflareCucumberFormatter = class extends 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,