@arghajit/playwright-pulse-report 0.3.4 → 0.3.5

package/scripts/{merge-pulse-report.js → merge-pulse-report.mjs}

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const path = require("path");
+import * as fs from "fs";
+import path from "path";
+import { getReporterConfig } from "./config-reader.mjs";
+import { animate } from "./terminal-logo.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 const args = process.argv.slice(2);
 let customOutputDir = null;
@@ -13,61 +16,63 @@ for (let i = 0; i < args.length; i++) {
   }
 }
 
-const OUTPUT_FILE = "playwright-pulse-report.json";
-
 /**
- * Securely resolves the report directory.
- * Prevents Path Traversal by ensuring the output directory
- * is contained within the current working directory.
+ * Securely resolves the report directory and config.
  */
-async function getReportDir() {
+async function getFullConfig() {
+  const config = await getReporterConfig(customOutputDir);
+  
   if (customOutputDir) {
     const resolvedPath = path.resolve(process.cwd(), customOutputDir);
-
     if (!resolvedPath.startsWith(process.cwd())) {
       console.error(
         "⛔ Security Error: Custom output directory must be within the current project root.",
       );
       process.exit(1);
     }
-
-    return resolvedPath;
   }
 
-  try {
-    const { getOutputDir } = await import("./config-reader.mjs");
-    return await getOutputDir();
-  } catch (error) {
-    return path.resolve(process.cwd(), "pulse-report");
-  }
+  return config;
 }
 
 /**
  * Scans the report directory for subdirectories (shards).
  * Returns an array of absolute paths to these subdirectories.
- * Excludes the 'attachments' folder itself.
+ * Excludes the 'attachments' folder and non-shard directories.
  */
-function getShardDirectories(dir) {
+function getShardDirectories(dir, outputFile, individualReportsSubDir) {
   if (!fs.existsSync(dir)) {
     return [];
   }
 
   return fs
     .readdirSync(dir, { withFileTypes: true })
-    .filter((dirent) => dirent.isDirectory() && dirent.name !== "attachments")
+    .filter((dirent) => {
+      if (!dirent.isDirectory() || dirent.name === "attachments" || dirent.name === individualReportsSubDir) {
+        return false;
+      }
+      
+      const shardPath = path.join(dir, dirent.name);
+      const hasDirectReport = fs.existsSync(path.join(shardPath, outputFile));
+      const hasSequentialResults = fs.existsSync(path.join(shardPath, individualReportsSubDir));
+      
+      // Scenario 3: Only consider directories that have either a report or sequential results
+      return hasDirectReport || hasSequentialResults;
+    })
     .map((dirent) => path.join(dir, dirent.name));
 }
 
 /**
  * Merges JSON reports from all shard directories.
  */
-function mergeReports(shardDirs) {
+function mergeReports(shardDirs, outputFile) {
   let combinedRun = {
     totalTests: 0,
     passed: 0,
     failed: 0,
     skipped: 0,
     duration: 0,
+    flaky: 0
   };
 
   let combinedResults = [];
@@ -76,10 +81,10 @@ function mergeReports(shardDirs) {
   let allEnvironments = [];
 
   for (const shardDir of shardDirs) {
-    const jsonPath = path.join(shardDir, OUTPUT_FILE);
+    const jsonPath = path.join(shardDir, outputFile);
 
     if (!fs.existsSync(jsonPath)) {
-      console.warn(`  Warning: No ${OUTPUT_FILE} found in ${path.basename(shardDir)}`);
+      console.warn(`  Warning: No ${outputFile} found in ${path.basename(shardDir)} after pre-merge attempt.`);
       continue;
     }
 
@@ -92,7 +97,7 @@ function mergeReports(shardDirs) {
       combinedRun.passed += run.passed || 0;
       combinedRun.failed += run.failed || 0;
       combinedRun.skipped += run.skipped || 0;
-      combinedRun.flaky = (combinedRun.flaky || 0) + (run.flaky || 0);
+      combinedRun.flaky += run.flaky || 0;
       combinedRun.duration += run.duration || 0;
 
       if (run.environment) {
@@ -181,13 +186,16 @@ function cleanupShardDirectories(shardDirs) {
 
 // Main execution
 (async () => {
-  const { animate } = await import("./terminal-logo.mjs");
   await animate();
   
-  const REPORT_DIR = await getReportDir();
+  const config = await getFullConfig();
+  const REPORT_DIR = config.outputDir;
+  const OUTPUT_FILE = config.outputFile;
+  const INDIVIDUAL_SUBDIR = config.individualReportsSubDir;
 
   console.log(`\n🔄 Playwright Pulse - Merge Reports (Sharding Mode)\n`);
   console.log(`  Report directory: ${REPORT_DIR}`);
+  console.log(`  Output file: ${OUTPUT_FILE}`);
   if (customOutputDir) {
     console.log(`  (from CLI argument)`);
   } else {
@@ -195,13 +203,13 @@ function cleanupShardDirectories(shardDirs) {
   }
   console.log();
 
-  // 1. Get Shard Directories
-  const shardDirs = getShardDirectories(REPORT_DIR);
+  // 1. Get initial Shard Directories (Scenario 3: filtering non-relevant folders)
+  const shardDirs = getShardDirectories(REPORT_DIR, OUTPUT_FILE, INDIVIDUAL_SUBDIR);
 
   if (shardDirs.length === 0) {
     console.log("❌ No shard directories found.");
     console.log(
-      "   Expected structure: <report-dir>/<shard-folder>/playwright-pulse-report.json",
+      `   Expected structure: <report-dir>/<shard-folder>/${OUTPUT_FILE} or <report-dir>/<shard-folder>/${INDIVIDUAL_SUBDIR}/`,
     );
     process.exit(0);
   }
@@ -212,18 +220,30 @@ function cleanupShardDirectories(shardDirs) {
   });
   console.log();
 
-  // 2. Merge JSON Reports
-  console.log(`🔀 Merging reports...`);
-  const merged = mergeReports(shardDirs);
+  // 2. Scenario 1: Pre-merge sequential results for EACH shard if needed
+  console.log(`⚙️  Checking for sequential results in shards...`);
+  for (const shardDir of shardDirs) {
+    const hasSequential = fs.existsSync(path.join(shardDir, INDIVIDUAL_SUBDIR));
+    if (hasSequential) {
+      console.log(`  - ${path.basename(shardDir)}: Merging sequential results...`);
+      // Force merge because individual shard dirs might not have playwright.config.ts resolving to resetOnEachRun=false
+      await mergeSequentialReportsIfNeeded(shardDir, true);
+    }
+  }
+  console.log();
+
+  // 3. Merge JSON Reports
+  console.log(`🔀 Merging reports across shards...`);
+  const merged = mergeReports(shardDirs, OUTPUT_FILE);
   console.log(`  ✓ Merged ${shardDirs.length} report(s)`);
   console.log();
 
-  // 3. Copy Attachments
+  // 4. Copy Attachments
   console.log(`📎 Merging attachments...`);
   mergeAttachments(shardDirs, REPORT_DIR);
   console.log(`  ✓ Attachments merged`);
 
-  // 4. Write Final Merged JSON
+  // 5. Write Final Merged JSON
   const finalReportPath = path.join(REPORT_DIR, OUTPUT_FILE);
   fs.writeFileSync(finalReportPath, JSON.stringify(merged, null, 2));
 
@@ -231,7 +251,7 @@ function cleanupShardDirectories(shardDirs) {
   console.log(`   Total tests: ${merged.run.totalTests}`);
   console.log(`   Passed: ${merged.run.passed} | Failed: ${merged.run.failed} | Skipped: ${merged.run.skipped} | Flaky: ${merged.run.flaky}`);
 
-  // 5. Cleanup Shard Directories
+  // 6. Cleanup Shard Directories
   cleanupShardDirectories(shardDirs);
 
   console.log();

package/scripts/merge-sequential-reports.mjs

@@ -0,0 +1,172 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+
+import { getReporterConfig } from "./config-reader.mjs";
+
+/**
+ * Reads all `<outputFile>-*.json` files in the `pulse-results` directory
+ * and merges them into a single `<outputFile>.json`.
+ * It resolves duplicate tests using exactly the same logic as the reporter.
+ * 
+ * @param {string} customOutputDir The base report directory override (from CLI).
+ * @param {boolean} forceMerge Try to merge regardless of config.resetOnEachRun (used by sharded merge).
+ */
+export async function mergeSequentialReportsIfNeeded(customOutputDir, forceMerge = false) {
+  const config = await getReporterConfig(customOutputDir);
+
+  // This logic should ONLY run if resetOnEachRun is disabled, UNLESS we are forcing it 
+  // (e.g. recovering orphaned shards in merge-pulse-report.mjs).
+  if (config.resetOnEachRun && !forceMerge) {
+    return;
+  }
+
+  const individualReportsSubDir = config.individualReportsSubDir;
+  const baseOutputFile = config.outputFile;
+  
+  // If customOutputDir is provided, it might be an absolute path to a shard. Use it directly if it is absolute.
+  // Otherwise, fall back to the config's outputDir (which is resolved relative to CWD).
+  const outputDir = customOutputDir && path.isAbsolute(customOutputDir) 
+    ? customOutputDir 
+    : config.outputDir;
+
+  const pulseResultsDir = path.join(outputDir, individualReportsSubDir);
+  const finalOutputPath = path.join(outputDir, baseOutputFile);
+
+  // Use the actual outputFile name as seed for shard files (e.g. "results.json" -> "results-")
+  const shardPrefix = baseOutputFile.replace(".json", "-");
+
+  let reportFiles;
+  try {
+    const allFiles = await fs.readdir(pulseResultsDir);
+    reportFiles = allFiles.filter(
+      (file) =>
+        file.startsWith(shardPrefix) && file.endsWith(".json"),
+    );
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      // No individual reports directory found, which is completely fine/normal
+      return;
+    }
+    console.error(
+      `Pulse Reporter: Error reading directory ${pulseResultsDir}:`,
+      error,
+    );
+    return;
+  }
+
+  if (reportFiles.length === 0) {
+    // No matching JSON report files found to merge
+    return;
+  }
+
+  console.log(
+    `\n🔄 Merging ${reportFiles.length} sequential test run(s) from '${individualReportsSubDir}'...`,
+  );
+
+  const allResultsFromAllFiles = [];
+  let latestTimestamp = new Date(0);
+  let lastRunEnvironment = undefined;
+  let totalDuration = 0;
+
+  for (const file of reportFiles) {
+    const filePath = path.join(pulseResultsDir, file);
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      const json = JSON.parse(content);
+
+      let currentRunId = `run-${Date.now()}`;
+      if (json.run) {
+        if (json.run.id) currentRunId = json.run.id;
+        
+        const runTimestamp = new Date(json.run.timestamp);
+        if (runTimestamp > latestTimestamp) {
+          latestTimestamp = runTimestamp;
+          lastRunEnvironment = json.run.environment || undefined;
+        }
+      }
+
+      if (json.results) {
+        // Tag each result with its runId to ensure we can sum them up if they have same IDs but different runs
+        const resultsWithRunId = json.results.map((r) => ({
+          ...r,
+          runId: currentRunId,
+        }));
+        allResultsFromAllFiles.push(...resultsWithRunId);
+      }
+    } catch (err) {
+      console.warn(
+        `Pulse Reporter: Could not parse report file ${filePath}. Skipping. Error: ${err.message}`,
+      );
+    }
+  }
+
+  // The results from individual run JSONs are already finalized and deduplicated by their own run's reporter.
+  // We simply concatenate them. The runId tag ensures tests across runs remain distinguishable.
+  const finalMergedResults = allResultsFromAllFiles;
+
+  totalDuration = finalMergedResults.reduce(
+    (acc, r) => acc + (r.duration || 0),
+    0,
+  );
+
+  const combinedRun = {
+    id: `run-${Date.now()}`,
+    timestamp: latestTimestamp.toISOString(),
+    environment: lastRunEnvironment,
+    totalTests: finalMergedResults.length,
+    passed: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "passed",
+    ).length,
+    failed: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "failed",
+    ).length,
+    skipped: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "skipped",
+    ).length,
+    flaky: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "flaky",
+    ).length,
+    duration: totalDuration,
+  };
+
+  const finalReport = {
+    run: combinedRun,
+    results: finalMergedResults,
+    metadata: {
+      generatedAt: new Date().toISOString(),
+    },
+  };
+
+  try {
+    await fs.writeFile(
+      finalOutputPath,
+      JSON.stringify(
+        finalReport,
+        (key, value) => {
+          if (value instanceof Date) return value.toISOString();
+          return value;
+        },
+        2,
+      ),
+    );
+    console.log(
+      `✅ Merged report with ${finalMergedResults.length} total results saved to ${finalOutputPath}`,
+    );
+
+    // Clean up the pulse-results directory after a successful merge
+    try {
+      await fs.rm(pulseResultsDir, { recursive: true, force: true });
+      console.log(
+        `🧹 Cleaned up temporary reports directory at ${pulseResultsDir}`,
+      );
+    } catch (cleanupErr) {
+      console.warn(
+        `Pulse Reporter: Could not clean up individual reports directory. Error: ${cleanupErr.message}`,
+      );
+    }
+  } catch (err) {
+    console.error(
+      `Pulse Reporter: Failed to write final merged report to ${finalOutputPath}. Error: ${err.message}`,
+    );
+  }
+}