@arghajit/playwright-pulse-report 0.2.0 → 0.2.1

package/scripts/generate-trend.mjs

@@ -0,0 +1,165 @@
+import * as fs from "fs/promises";
+import path from "path";
+// XLSX is NO LONGER NEEDED here
+
+// Use dynamic import for chalk as it's ESM only for prettier console logs
+let chalk;
+try {
+  chalk = (await import("chalk")).default;
+} catch (e) {
+  chalk = {
+    green: (t) => t,
+    red: (t) => t,
+    yellow: (t) => t,
+    blue: (t) => t,
+    bold: (t) => t,
+  };
+}
+
+const DEFAULT_OUTPUT_DIR = "pulse-report";
+const CURRENT_RUN_JSON_FILE = "playwright-pulse-report.json"; // Source of the current run data
+const HISTORY_SUBDIR = "history"; // Subdirectory for historical JSON files
+const HISTORY_FILE_PREFIX = "trend-";
+const MAX_HISTORY_FILES = 15; // Store last 15 runs
+
+async function archiveCurrentRunData() {
+  const outputDir = path.resolve(process.cwd(), DEFAULT_OUTPUT_DIR);
+  const currentRunJsonPath = path.join(outputDir, CURRENT_RUN_JSON_FILE);
+  const historyDir = path.join(outputDir, HISTORY_SUBDIR);
+
+  try {
+    // 1. Ensure history directory exists
+    await fs.mkdir(historyDir, { recursive: true });
+    // console.log(chalk.blue(`History directory ensured at: ${historyDir}`));
+
+    // 2. Read the current run's JSON data
+    // console.log(chalk.blue(`Reading current run data from: ${currentRunJsonPath}`));
+    let currentReportData;
+    try {
+      const jsonData = await fs.readFile(currentRunJsonPath, "utf-8");
+      currentReportData = JSON.parse(jsonData);
+      if (
+        !currentReportData ||
+        !currentReportData.run ||
+        !currentReportData.run.timestamp
+      ) {
+        throw new Error(
+          "Invalid current run JSON report structure. Missing 'run' or 'run.timestamp' data."
+        );
+      }
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `Error reading or parsing current run JSON report at ${currentRunJsonPath}: ${error.message}`
+        )
+      );
+      process.exit(1); // Exit if we can't read the source file
+    }
+
+    // 3. Determine the filename for the new history file
+    // Ensure timestamp is a valid number before using getTime()
+    let runTimestampMs;
+    try {
+      runTimestampMs = new Date(currentReportData.run.timestamp).getTime();
+      if (isNaN(runTimestampMs)) {
+        throw new Error(
+          `Invalid timestamp value: ${currentReportData.run.timestamp}`
+        );
+      }
+    } catch (dateError) {
+      console.error(
+        chalk.red(
+          `Failed to parse timestamp '${currentReportData.run.timestamp}': ${dateError.message}`
+        )
+      );
+      process.exit(1);
+    }
+
+    const newHistoryFileName = `${HISTORY_FILE_PREFIX}${runTimestampMs}.json`;
+    const newHistoryFilePath = path.join(historyDir, newHistoryFileName);
+
+    // 4. Write the current run's data to the new history file
+    // console.log(chalk.blue(`Saving current run data to: ${newHistoryFilePath}`));
+    await fs.writeFile(
+      newHistoryFilePath,
+      JSON.stringify(currentReportData, null, 2),
+      "utf-8"
+    );
+    console.log(chalk.green(`Archived current run to: ${newHistoryFilePath}`));
+
+    // 5. Prune old history files
+    await pruneOldHistoryFiles(historyDir);
+  } catch (error) {
+    console.error(
+      chalk.red(`Error in archiveCurrentRunData: ${error.message}`)
+    );
+    // console.error(error.stack); // Uncomment for more detailed stack trace
+    process.exit(1);
+  }
+}
+
+async function pruneOldHistoryFiles(historyDir) {
+  // console.log(chalk.blue(`Pruning old history files in ${historyDir} (keeping last ${MAX_HISTORY_FILES})...`));
+  try {
+    const files = await fs.readdir(historyDir);
+    const historyJsonFiles = files
+      .filter(
+        (file) => file.startsWith(HISTORY_FILE_PREFIX) && file.endsWith(".json")
+      )
+      .map((file) => {
+        const timestampPart = file
+          .replace(HISTORY_FILE_PREFIX, "")
+          .replace(".json", "");
+        return { name: file, timestamp: parseInt(timestampPart, 10) };
+      })
+      .filter((file) => !isNaN(file.timestamp))
+      .sort((a, b) => a.timestamp - b.timestamp); // Sort ascending (oldest first)
+
+    if (historyJsonFiles.length > MAX_HISTORY_FILES) {
+      const filesToDelete = historyJsonFiles.slice(
+        0,
+        historyJsonFiles.length - MAX_HISTORY_FILES
+      );
+      console.log(
+        chalk.yellow(
+          `Found ${historyJsonFiles.length} history files. Pruning ${filesToDelete.length} oldest file(s)...`
+        )
+      );
+      for (const fileMeta of filesToDelete) {
+        const filePathToDelete = path.join(historyDir, fileMeta.name);
+        try {
+          await fs.unlink(filePathToDelete);
+          // console.log(chalk.gray(`Deleted old history file: ${fileMeta.name}`));
+        } catch (deleteError) {
+          console.warn(
+            chalk.yellow(
+              `Could not delete old history file ${fileMeta.name}: ${deleteError.message}`
+            )
+          );
+        }
+      }
+    } else {
+      // console.log(chalk.green(`Found ${historyJsonFiles.length} history files. No pruning needed.`));
+    }
+  } catch (error) {
+    console.warn(
+      chalk.yellow(
+        `Warning during history pruning in ${historyDir}: ${error.message}`
+      )
+    );
+    // Don't exit for pruning errors, as saving the current run is more critical
+  }
+}
+
+// Main execution
+archiveCurrentRunData().catch((error) => {
+  // Fallback catch, though critical errors in archiveCurrentRunData should exit
+  if (process.exitCode === undefined || process.exitCode === 0) {
+    // check if not already exited
+    console.error(
+      chalk.red.bold("An unexpected error occurred in history archiving:"),
+      error
+    );
+    process.exit(1);
+  }
+});

package/scripts/generate-trend-excel.mjs

@@ -1,273 +0,0 @@
-// generate-trend-excel.mjs
-import * as fs from "fs/promises";
-import path from "path";
-import * as XLSX from "xlsx";
-
-// Use dynamic import for chalk as it's ESM only for prettier console logs
-let chalk;
-try {
-  chalk = (await import("chalk")).default;
-} catch (e) {
-  chalk = { green: (t) => t, red: (t) => t, yellow: (t) => t, blue: (t) => t }; // Basic fallback
-}
-
-const DEFAULT_OUTPUT_DIR = "pulse-report"; // Should match reporter's outputDir
-const DEFAULT_JSON_FILE = "playwright-pulse-report.json";
-const TREND_EXCEL_FILE_NAME = "trend.xls";
-
-class ExcelTrendManager {
-  _excelFilePath;
-  _maxRuns = 5;
-
-  constructor(outputDir, excelFileName = TREND_EXCEL_FILE_NAME) {
-    this._excelFilePath = path.join(outputDir, excelFileName);
-  }
-
-  getExcelFilePath() {
-    return this._excelFilePath;
-  }
-
-  async _readExistingData() {
-    try {
-      await fs.access(this._excelFilePath);
-      const buffer = await fs.readFile(this._excelFilePath);
-      return XLSX.read(buffer, { type: "buffer" });
-    } catch {
-      return null;
-    }
-  }
-
-  _shiftOverallRuns(data, currentNumericRunId) {
-    const validData = Array.isArray(data) ? data : [];
-    const pastOrCurrentData = validData.filter(
-      (row) =>
-        row.hasOwnProperty("RUN_ID") &&
-        typeof row.RUN_ID === "number" &&
-        row.RUN_ID <= currentNumericRunId
-    );
-    const sortedData = [...pastOrCurrentData].sort(
-      (a, b) => a.RUN_ID - b.RUN_ID
-    );
-    if (sortedData.length > this._maxRuns) {
-      return sortedData.slice(sortedData.length - this._maxRuns);
-    }
-    return sortedData;
-  }
-
-  async updateTrendData(
-    runIdFromReport,
-    timestamp,
-    totalTests,
-    passed,
-    failed,
-    skipped,
-    duration,
-    testResultsForThisRun
-  ) {
-    let workbook = await this._readExistingData();
-    const numericRunId = Math.floor(timestamp / 1000);
-
-    if (!workbook) {
-      workbook = XLSX.utils.book_new();
-      // If the workbook is new, SheetNames will be empty.
-      // We need to initialize it if it doesn't exist
-      if (!workbook.SheetNames) {
-        workbook.SheetNames = [];
-      }
-    } else {
-      // Ensure SheetNames exists even for existing workbooks (should, but defensive)
-      if (!workbook.SheetNames) {
-        workbook.SheetNames = [];
-      }
-    }
-
-    // --- Overall Data ---
-    let existingOverallData = [];
-    if (workbook.Sheets["overall"]) {
-      try {
-        existingOverallData = XLSX.utils.sheet_to_json(
-          workbook.Sheets["overall"]
-        );
-      } catch (e) {
-        console.warn(
-          chalk.yellow(
-            "Could not parse existing 'overall' sheet. Starting fresh. Error:",
-            e.message
-          )
-        );
-        existingOverallData = [];
-      }
-    }
-    existingOverallData = existingOverallData.filter(
-      (row) => row.RUN_ID !== numericRunId
-    );
-    const newOverallRow = {
-      RUN_ID: numericRunId,
-      DURATION: duration,
-      TIMESTAMP: timestamp,
-      TOTAL_TESTS: totalTests,
-      PASSED: passed,
-      FAILED: failed,
-      SKIPPED: skipped,
-    };
-    let updatedOverallData = [...existingOverallData, newOverallRow];
-    updatedOverallData = this._shiftOverallRuns(
-      updatedOverallData,
-      numericRunId
-    );
-
-    const overallSheet = XLSX.utils.json_to_sheet(updatedOverallData);
-
-    // UPDATED: Use book_append_sheet for new sheets, or replace existing
-    if (!workbook.SheetNames.includes("overall")) {
-      XLSX.utils.book_append_sheet(workbook, overallSheet, "overall");
-      // Move "overall" to the beginning if it was just added and not already first
-      const overallIndex = workbook.SheetNames.indexOf("overall");
-      if (overallIndex > 0) {
-        const sheetName = workbook.SheetNames.splice(overallIndex, 1)[0];
-        workbook.SheetNames.unshift(sheetName);
-      }
-    } else {
-      workbook.Sheets["overall"] = overallSheet; // Replace existing
-    }
-    XLSX.utils.book_set_sheet_visibility(workbook, "overall", 0);
-
-    // --- Per-Test Data Sheet for the Current Run ---
-    const runKey = `test run ${numericRunId}`;
-    const currentRunTestData = testResultsForThisRun.map((test) => ({
-      TEST_NAME: test.name,
-      DURATION: test.duration,
-      STATUS: test.status,
-      TIMESTAMP: timestamp,
-    }));
-    const testRunSheet = XLSX.utils.json_to_sheet(currentRunTestData);
-
-    // UPDATED: Logic to add or replace the sheet and ensure it's in SheetNames
-    if (!workbook.SheetNames.includes(runKey)) {
-      XLSX.utils.book_append_sheet(workbook, testRunSheet, runKey); // This adds to Sheets and SheetNames
-    } else {
-      workbook.Sheets[runKey] = testRunSheet; // Just replace the sheet data
-    }
-    // Now that the sheet is guaranteed to be in SheetNames and workbook.Sheets, set visibility
-    XLSX.utils.book_set_sheet_visibility(workbook, runKey, 0);
-
-    // --- Maintain Max Sheet Count for Individual Test Runs ---
-    let testRunSheetNames = workbook.SheetNames.filter(
-      (name) => name.toLowerCase().startsWith("test run ") && name !== "overall"
-    );
-    testRunSheetNames.sort((a, b) => {
-      const matchA = a.match(/test run (\d+)$/i);
-      const matchB = b.match(/test run (\d+)$/i);
-      const idA = matchA && matchA[1] ? parseInt(matchA[1], 10) : 0;
-      const idB = matchB && matchB[1] ? parseInt(matchB[1], 10) : 0;
-      return idA - idB;
-    });
-
-    if (testRunSheetNames.length > this._maxRuns) {
-      const sheetsToRemoveCount = testRunSheetNames.length - this._maxRuns;
-      const removedSheetNames = [];
-      for (let i = 0; i < sheetsToRemoveCount; i++) {
-        const oldestSheetName = testRunSheetNames[i];
-        // Remove from workbook.Sheets
-        delete workbook.Sheets[oldestSheetName];
-        removedSheetNames.push(oldestSheetName);
-      }
-      // Rebuild SheetNames array without the removed sheets
-      workbook.SheetNames = workbook.SheetNames.filter(
-        (name) => !removedSheetNames.includes(name)
-      );
-    }
-
-    // --- Write Workbook ---
-    try {
-      const buffer = XLSX.write(workbook, { bookType: "xls", type: "buffer" });
-      await fs.writeFile(this._excelFilePath, buffer);
-      console.log(
-        chalk.green(
-          `Excel trend report updated successfully at ${this._excelFilePath}`
-        )
-      );
-    } catch (writeError) {
-      console.error(
-        chalk.red(`Failed to write Excel file at ${this._excelFilePath}`)
-      );
-      console.error(chalk.red("Write Error Details:"), writeError);
-      throw writeError;
-    }
-  }
-}
-
-async function generateTrendExcel() {
-  const outputDir = path.resolve(process.cwd(), DEFAULT_OUTPUT_DIR);
-  const jsonReportPath = path.join(outputDir, DEFAULT_JSON_FILE);
-
-  // Ensure output directory exists before any file operations
-  try {
-    await fs.mkdir(outputDir, { recursive: true });
-  } catch (mkdirError) {
-    console.error(
-      chalk.red(`Failed to create output directory ${outputDir}:`),
-      mkdirError
-    );
-    process.exit(1);
-  }
-
-  console.log(chalk.blue(`Reading JSON report from: ${jsonReportPath}`));
-  let reportData;
-  try {
-    const jsonData = await fs.readFile(jsonReportPath, "utf-8");
-    reportData = JSON.parse(jsonData);
-    if (!reportData || !reportData.run || !Array.isArray(reportData.results)) {
-      throw new Error(
-        "Invalid JSON report structure. Missing 'run' or 'results' data."
-      );
-    }
-  } catch (error) {
-    console.error(
-      chalk.red(`Error reading or parsing JSON report: ${error.message}`)
-    );
-    console.error(chalk.red("JSON Read/Parse Error Details:"), error);
-    process.exit(1);
-  }
-
-  const { run, results } = reportData;
-  if (!run.timestamp || isNaN(new Date(run.timestamp).getTime())) {
-    console.error(
-      chalk.red(`Invalid or missing run.timestamp in JSON: ${run.timestamp}`)
-    );
-    process.exit(1);
-  }
-  const runTimestamp = new Date(run.timestamp).getTime();
-
-  const testResultsForExcel = results.map((r) => ({
-    name: r.name,
-    duration: r.duration,
-    status: r.status,
-  }));
-
-  const excelManager = new ExcelTrendManager(outputDir);
-  try {
-    await excelManager.updateTrendData(
-      run.id,
-      runTimestamp,
-      run.totalTests,
-      run.passed,
-      run.failed,
-      run.skipped,
-      run.duration,
-      testResultsForExcel
-    );
-  } catch (excelError) {
-    console.error(chalk.red("Aborting due to error during Excel generation."));
-    console.error(chalk.red("Excel Generation Error Details:"), excelError);
-    process.exit(1);
-  }
-}
-
-generateTrendExcel().catch((error) => {
-  console.error(
-    chalk.red("An unexpected error occurred in generate-trend-excel:"),
-    error
-  );
-  process.exit(1);
-});