@qualflare/playwright 0.2.0 → 0.4.0

package/dist/reporter/index.js

@@ -15,7 +15,14 @@ var MAX_LABELS_PER_CASE = 100;
 var MAX_LINKS_PER_CASE = 20;
 var MAX_TAGS_PER_CASE = 64;
 var MAX_TAG_LENGTH = 255;
+var MAX_ATTEMPTS_PER_CASE = 50;
+var MAX_ATTEMPT_MESSAGE_RUNES = 8192;
+var MAX_ATTEMPT_TRACE_RUNES = 32768;
+var MAX_ATTEMPT_SNIPPET_RUNES = 4096;
+var MAX_ATTEMPT_OUTPUT_RUNES = 16384;
+var MAX_ATTEMPT_OUTPUT_LINES = 200;
 var MAX_VIDEO_UPLOAD_BYTES = 50 * 1024 * 1024;
+var MAX_TRACE_UPLOAD_BYTES = 50 * 1024 * 1024;
 var MAX_STEPS_PER_TEST_ATTEMPT = 300;
 
 // src/config/ci-detect.ts
@@ -243,6 +250,7 @@ function resolveConfig(options, deps = {}) {
     maxAttachmentBytes: options.maxAttachmentBytes ?? envInt("QUALFLARE_MAX_ATTACHMENT_BYTES") ?? 15e5,
     maxTotalAttachmentBytes: options.maxTotalAttachmentBytes ?? envInt("QUALFLARE_MAX_TOTAL_ATTACHMENT_BYTES") ?? 75e4,
     maxVideoBytes: options.maxVideoBytes ?? envInt("QUALFLARE_MAX_VIDEO_BYTES") ?? MAX_VIDEO_UPLOAD_BYTES,
+    maxTraceBytes: options.maxTraceBytes ?? envInt("QUALFLARE_MAX_TRACE_BYTES") ?? MAX_TRACE_UPLOAD_BYTES,
     debug: options.debug ?? envBool("QUALFLARE_DEBUG", "QF_DEBUG") ?? false,
     enabled,
     outputDir,
@@ -279,35 +287,51 @@ var VIDEO_MIME_TYPES_BY_EXTENSION = {
   ".webm": "video/webm",
   ".mov": "video/quicktime"
 };
-function copyVideoAttachment(filePath, outputDir, maxVideoBytes) {
-  const ext = path.extname(filePath).toLowerCase();
-  const mimeType = VIDEO_MIME_TYPES_BY_EXTENSION[ext];
-  if (!mimeType) {
-    logger.warn(`skipping video attachment "${filePath}": unsupported video format.`);
-    return void 0;
-  }
+var TRACE_MIME_TYPE = "application/zip";
+var TRACE_EXTENSION = ".zip";
+function copyArtifact(filePath, outputDir, maxBytes, ext, capName, label) {
   let fileSize;
   try {
     fileSize = fs.statSync(filePath).size;
   } catch (err) {
-    logger.warn(`skipping video attachment "${filePath}": could not stat file: ${err.message}`);
+    logger.warn(`skipping ${label} attachment "${filePath}": could not stat file: ${err.message}`);
     return void 0;
   }
-  if (fileSize > maxVideoBytes) {
+  if (fileSize > maxBytes) {
     logger.warn(
-      `skipping video attachment "${filePath}": ${fileSize} bytes exceeds the configured maxVideoBytes cap of ${maxVideoBytes} bytes.`
+      `skipping ${label} attachment "${filePath}": ${fileSize} bytes exceeds the configured ${capName} cap of ${maxBytes} bytes.`
     );
     return void 0;
   }
-  const localVideoPath = `${randomUUID2()}${ext}`;
+  const localPath = `${randomUUID2()}${ext}`;
   try {
     fs.mkdirSync(outputDir, { recursive: true });
-    fs.copyFileSync(filePath, path.join(outputDir, localVideoPath));
+    fs.copyFileSync(filePath, path.join(outputDir, localPath));
   } catch (err) {
-    logger.warn(`skipping video attachment "${filePath}": could not copy file: ${err.message}`);
+    logger.warn(`skipping ${label} attachment "${filePath}": could not copy file: ${err.message}`);
+    return void 0;
+  }
+  return { localPath, fileSize };
+}
+function copyVideoAttachment(filePath, outputDir, maxVideoBytes) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = VIDEO_MIME_TYPES_BY_EXTENSION[ext];
+  if (!mimeType) {
+    logger.warn(`skipping video attachment "${filePath}": unsupported video format.`);
+    return void 0;
+  }
+  const copied = copyArtifact(filePath, outputDir, maxVideoBytes, ext, "maxVideoBytes", "video");
+  if (!copied) {
     return void 0;
   }
-  return { localVideoPath, fileSize, mimeType };
+  return { localVideoPath: copied.localPath, fileSize: copied.fileSize, mimeType };
+}
+function copyTraceAttachment(filePath, outputDir, maxTraceBytes) {
+  const copied = copyArtifact(filePath, outputDir, maxTraceBytes, TRACE_EXTENSION, "maxTraceBytes", "trace");
+  if (!copied) {
+    return void 0;
+  }
+  return { localTracePath: copied.localPath, fileSize: copied.fileSize, mimeType: TRACE_MIME_TYPE };
 }
 
 // src/reporter/attachment-reader.ts
@@ -337,6 +361,7 @@ var AttachmentBudget = class {
 };
 var NAME_VIDEO = "video";
 var NAME_TRACE = "trace";
+var TRACE_CONTENT_TYPE = "application/zip";
 function isVideo(a) {
   return a.name === NAME_VIDEO || (a.contentType?.startsWith("video/") ?? false);
 }
@@ -357,7 +382,20 @@ function resolveAttachments(result, config, budget) {
       }
       break;
     }
-    if (a.name === NAME_TRACE || a.contentType === "application/zip") {
+    if (a.name === NAME_TRACE || a.contentType === TRACE_CONTENT_TYPE) {
+      if (!a.path) {
+        logger.warn(`skipping in-memory trace attachment "${a.name}": only file-backed traces are supported.`);
+        continue;
+      }
+      const copied = copyTraceAttachment(a.path, config.outputDir, config.maxTraceBytes);
+      if (copied) {
+        out.push({
+          name: a.name,
+          mimeType: copied.mimeType,
+          localTracePath: copied.localTracePath,
+          fileSize: copied.fileSize
+        });
+      }
       continue;
     }
     if (isVideo(a)) {
@@ -445,6 +483,34 @@ function msToNs(ms) {
   return Math.round(ms * NS_PER_MS);
 }
 
+// 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("");
+}
+function clampOutputLines(lines, maxLines, maxRunes) {
+  const out = [];
+  let budget = maxRunes;
+  for (const line of lines.slice(0, maxLines)) {
+    const cost = Array.from(line).length + 1;
+    if (cost > budget) {
+      if (budget > 1) {
+        out.push(truncateRunes(line, budget - 1));
+      }
+      break;
+    }
+    out.push(line);
+    budget -= cost;
+  }
+  return out.length > 0 ? out : void 0;
+}
+
 // src/reporter/step-mapper.ts
 var CATEGORY_TEST_STEP = "test.step";
 var CATEGORY_EXPECT = "expect";
@@ -553,6 +619,63 @@ function formatError(result) {
   }
   return parts.join("\n");
 }
+function outputLines(chunks) {
+  if (!chunks || chunks.length === 0) {
+    return void 0;
+  }
+  const text = chunks.map((c) => typeof c === "string" ? c : c.toString("utf8")).join("");
+  const lines = stripAnsi(text).split("\n");
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return clampOutputLines(lines, MAX_ATTEMPT_OUTPUT_LINES, MAX_ATTEMPT_OUTPUT_RUNES);
+}
+function buildAttempts(results) {
+  if (results.length < 2) {
+    return void 0;
+  }
+  let kept = results;
+  if (results.length > MAX_ATTEMPTS_PER_CASE) {
+    kept = [...results.slice(0, MAX_ATTEMPTS_PER_CASE - 1), results[results.length - 1]];
+  }
+  return kept.map((r, i) => {
+    const err = r.error;
+    const attempt = {
+      // 1-based and contiguous. Deliberately the index rather than
+      // `r.retry`: results are already ordered by attempt, and a filtered-out
+      // never-ran result would leave a hole in the retry numbering that the
+      // server reads as a truncated history.
+      attempt: i + 1,
+      status: mapStatus(r.status),
+      duration: msToNs(r.duration),
+      startedAt: r.startTime.toISOString()
+    };
+    if (err) {
+      const message = err.message ?? err.value;
+      if (message) {
+        attempt.message = truncateRunes(stripAnsi(message), MAX_ATTEMPT_MESSAGE_RUNES);
+      }
+      if (err.stack) {
+        attempt.trace = truncateRunes(stripAnsi(err.stack), MAX_ATTEMPT_TRACE_RUNES);
+      }
+      if (err.snippet) {
+        attempt.snippet = truncateRunes(stripAnsi(err.snippet), MAX_ATTEMPT_SNIPPET_RUNES);
+      }
+      if (typeof err.location?.line === "number") {
+        attempt.line = err.location.line;
+      }
+    }
+    const stdout = outputLines(r.stdout);
+    if (stdout) {
+      attempt.stdout = stdout;
+    }
+    const stderr = outputLines(r.stderr);
+    if (stderr) {
+      attempt.stderr = stderr;
+    }
+    return attempt;
+  });
+}
 function replayMetadata(result, config, budget) {
   const meta = {
     labels: [],
@@ -675,6 +798,7 @@ function buildCase(test, config, attachmentsByResult, budget) {
   const nativeTags = test.tags ?? [];
   const tags = capTags([...nativeTags, ...meta.tags]);
   const error = formatError(final);
+  const attempts = buildAttempts(results);
   return {
     id: test.id,
     name: test.title,
@@ -683,6 +807,7 @@ function buildCase(test, config, attachmentsByResult, budget) {
     duration: msToNs(final.duration),
     retryCount: results.length - 1,
     isFlaky: outcome === "flaky",
+    ...attempts ? { attempts } : {},
     ...error ? { error } : {},
     ...meta.priority ? { priority: meta.priority } : {},
     ...meta.description ? { description: meta.description } : {},
@@ -700,7 +825,7 @@ function buildCase(test, config, attachmentsByResult, budget) {
 import * as os from "os";
 
 // src/config/version.ts
-var PACKAGE_VERSION = "0.2.0";
+var PACKAGE_VERSION = "0.4.0";
 
 // src/reporter/collect-builder.ts
 function resolveOs(config) {
@@ -891,7 +1016,8 @@ var QualflareReporter = class {
     return path3.isAbsolute(outputDir) ? outputDir : path3.resolve(this.options.configDir ?? this.rootDir, outputDir);
   }
   /** Drops everything an earlier, now-superseded attempt produced: deletes the
-   * video copied into outputDir and refunds its bytes to the run budget. */
+   * video or trace copied into outputDir and refunds its bytes to the run
+   * budget. */
   discardSupersededAttempt(testId, retry, outputDir) {
     const previous = this.latestAttemptByTest.get(testId);
     if (previous === void 0 || previous >= retry) {
@@ -899,9 +1025,10 @@ var QualflareReporter = class {
     }
     const key = `${testId}:${previous}`;
     for (const attachment of this.attachmentsByResult.get(key) ?? []) {
-      if (attachment.localVideoPath) {
+      const orphan = attachment.localVideoPath ?? attachment.localTracePath;
+      if (orphan) {
         try {
-          fs3.rmSync(path3.join(this.resolveOutputDir(outputDir), attachment.localVideoPath), { force: true });
+          fs3.rmSync(path3.join(this.resolveOutputDir(outputDir), orphan), { force: true });
         } catch {
         }
       }