@qualflare/playwright 0.3.0 → 0.4.1

package/dist/reporter/index.js

@@ -22,6 +22,7 @@ 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
@@ -249,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,
@@ -285,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;
   }
-  return { localVideoPath, fileSize, mimeType };
+  const copied = copyArtifact(filePath, outputDir, maxVideoBytes, ext, "maxVideoBytes", "video");
+  if (!copied) {
+    return void 0;
+  }
+  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
@@ -343,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);
 }
@@ -363,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)) {
@@ -793,7 +825,7 @@ function buildCase(test, config, attachmentsByResult, budget) {
 import * as os from "os";
 
 // src/config/version.ts
-var PACKAGE_VERSION = "0.3.0";
+var PACKAGE_VERSION = "0.4.1";
 
 // src/reporter/collect-builder.ts
 function resolveOs(config) {
@@ -984,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) {
@@ -992,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 {
         }
       }