@arghajit/dummy 0.1.0

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/merge-pulse-report.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const REPORT_DIR = "./pulse-report"; // Or change this to your reports directory
+const OUTPUT_FILE = "playwright-pulse-report.json";
+
+function getReportFiles(dir) {
+  return fs
+    .readdirSync(dir)
+    .filter(
+      (file) =>
+        file.startsWith("playwright-pulse-report-") && file.endsWith(".json")
+    );
+}
+
+function mergeReports(files) {
+  let combinedRun = {
+    totalTests: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    duration: 0,
+  };
+
+  let combinedResults = [];
+
+  let latestTimestamp = "";
+  let latestGeneratedAt = "";
+
+  for (const file of files) {
+    const filePath = path.join(REPORT_DIR, file);
+    const json = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+
+    const run = json.run || {};
+    combinedRun.totalTests += run.totalTests || 0;
+    combinedRun.passed += run.passed || 0;
+    combinedRun.failed += run.failed || 0;
+    combinedRun.skipped += run.skipped || 0;
+    combinedRun.duration += run.duration || 0;
+
+    if (json.results) {
+      combinedResults.push(...json.results);
+    }
+
+    if (run.timestamp > latestTimestamp) latestTimestamp = run.timestamp;
+    if (json.metadata?.generatedAt > latestGeneratedAt)
+      latestGeneratedAt = json.metadata.generatedAt;
+  }
+
+  const finalJson = {
+    run: {
+      id: `merged-${Date.now()}`,
+      timestamp: latestTimestamp,
+      ...combinedRun,
+    },
+    results: combinedResults,
+    metadata: {
+      generatedAt: latestGeneratedAt,
+    },
+  };
+
+  return finalJson;
+}
+
+// Main execution
+const reportFiles = getReportFiles(REPORT_DIR);
+
+if (reportFiles.length === 0) {
+  console.log("No matching JSON report files found.");
+  process.exit(1);
+}
+
+const merged = mergeReports(reportFiles);
+
+fs.writeFileSync(
+  path.join(REPORT_DIR, OUTPUT_FILE),
+  JSON.stringify(merged, null, 2)
+);
+console.log(`✅ Merged report saved as ${OUTPUT_FILE}`);

package/scripts/sendReport.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+const nodemailer = require("nodemailer");
+const path = require("path");
+const archiver = require("archiver");
+const fileSystem = require("fs");
+const reportDir = "./pulse-report";
+
+require("dotenv").config();
+
+let fetch;
+import("node-fetch")
+  .then((module) => {
+    fetch = module.default;
+  })
+  .catch((err) => {
+    console.error("Failed to import node-fetch:", err);
+    process.exit(1);
+  });
+
+let projectName;
+
+function getUUID() {
+  const reportPath = path.join(
+    process.cwd(),
+    `${reportDir}/playwright-pulse-report.json`
+  );
+  console.log("Report path:", reportPath);
+
+  if (!fileSystem.existsSync(reportPath)) {
+    throw new Error("Pulse report file not found.");
+  }
+
+  const content = JSON.parse(fileSystem.readFileSync(reportPath, "utf-8"));
+  const idString = content.run.id;
+  const parts = idString.split("-");
+  const uuid = parts.slice(-5).join("-");
+  return uuid;
+}
+
+function formatDuration(ms) {
+  const seconds = (ms / 1000).toFixed(2);
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${seconds}s`;
+  if (ms < 3600000) return `${(ms / 60000).toFixed(1)}min`;
+  return `${(ms / 3600000).toFixed(1)}h`;
+}
+const formatStartTime = (isoString) => {
+  const date = new Date(isoString);
+  return date.toLocaleString(); // Default locale
+};
+
+// Generate test-data from allure report
+const getPulseReportSummary = () => {
+  const reportPath = path.join(
+    process.cwd(),
+    `${reportDir}/playwright-pulse-report.json`
+  );
+
+  if (!fileSystem.existsSync(reportPath)) {
+    throw new Error("Pulse report file not found.");
+  }
+
+  const content = JSON.parse(fileSystem.readFileSync(reportPath, "utf-8"));
+  const run = content.run;
+
+  const total = run.totalTests || 0;
+  const passed = run.passed || 0;
+  const failed = run.failed || 0;
+  const skipped = run.skipped || 0;
+  const duration = (run.duration || 0) / 1000; // Convert ms to seconds
+
+  const readableStartTime = new Date(run.timestamp).toLocaleString();
+
+  return {
+    total,
+    passed,
+    failed,
+    skipped,
+    passedPercentage: total ? ((passed / total) * 100).toFixed(2) : "0.00",
+    failedPercentage: total ? ((failed / total) * 100).toFixed(2) : "0.00",
+    skippedPercentage: total ? ((skipped / total) * 100).toFixed(2) : "0.00",
+    startTime: readableStartTime,
+    duration: formatDuration(duration),
+  };
+};
+
+// sleep function for javascript file
+const delay = (time) => new Promise((resolve) => setTimeout(resolve, time));
+// Function to zip the folder asynchronously using async/await
+const zipFolder = async (folderPath, zipPath) => {
+  return new Promise((resolve, reject) => {
+    const output = fileSystem.createWriteStream(zipPath); // Must use require("fs") directly here
+    const archive = archiver("zip", { zlib: { level: 9 } });
+
+    output.on("close", () => {
+      console.log(`${archive.pointer()} total bytes`);
+      console.log("Folder has been zipped successfully.");
+      resolve(); // Resolve the promise after zipping is complete
+    });
+
+    archive.on("error", (err) => {
+      reject(err); // Reject the promise in case of an error
+    });
+
+    archive.pipe(output);
+    archive.directory(folderPath, false); // Zip the folder without the parent folder
+    archive.finalize(); // Finalize the archive
+  });
+};
+
+// Function to convert JSON data to HTML table format
+const generateHtmlTable = (data) => {
+  projectName = "Pulse Emailable Report";
+  const stats = data;
+  const total = stats.passed + stats.failed + stats.skipped;
+  const passedTests = stats.passed;
+  const passedPercentage = stats.passedPercentage;
+  const failedTests = stats.failed;
+  const failedPercentage = stats.failedPercentage;
+  const skippedTests = stats.skipped;
+  const skippedPercentage = stats.skippedPercentage;
+  const startTime = stats.startTime;
+  const durationSeconds = stats.duration;
+
+  return `
+  <!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Test Stats Report</title>
+    <style>
+      table {
+        width: 100%;
+        border-collapse: collapse;
+      }
+      table, th, td {
+        border: 1px solid black;
+      }
+      th, td {
+        padding: 8px;
+        text-align: left;
+      }
+      th {
+        background-color: #f2f2f2;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>${projectName} Statistics</h1>
+    <table>
+      <thead>
+        <tr>
+          <th>Metric</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td>Test Start Time</td>
+          <td>${startTime}</td>
+        </tr>
+        <tr>
+          <td>Test Run Duration (Seconds)</td>
+          <td>${durationSeconds}</td>
+        </tr>
+        <tr>
+          <td>Total Tests Count</td>
+          <td>${total}</td>
+        </tr>
+        <tr>
+          <td>Tests Passed</td>
+          <td>${passedTests} (${passedPercentage}%)</td>
+        </tr>
+        <tr>
+          <td>Skipped Tests</td>
+          <td>${skippedTests} (${skippedPercentage}%)</td>
+        </tr>
+        <tr>
+          <td>Test Failed</td>
+          <td>${failedTests} (${failedPercentage}%)</td>
+        </tr>
+      </tbody>
+    </table>
+    <p>With regards,</p>
+    <p>Networks QA Team</p>
+  </body>
+  </html>
+  `;
+};
+
+// Async function to send an email
+const sendEmail = async (credentials) => {
+  try {
+    console.log("Starting the sendEmail function...");
+
+    // Configure nodemailer transporter
+    const secureTransporter = nodemailer.createTransport({
+      host: "smtp.gmail.com",
+      port: 465,
+      secure: true, // Use SSL/TLS
+      auth: {
+        user: credentials.username,
+        pass: credentials.password, // Ensure you use app password or secured token
+      },
+    });
+    // Generate HTML content for email
+    const reportData = getPulseReportSummary();
+    const htmlContent = generateHtmlTable(reportData);
+
+    // Configure mail options
+    const mailOptions = {
+      from: credentials.username,
+      to: [
+        process.env.SENDER_EMAIL_1 || "",
+        process.env.SENDER_EMAIL_2 || "",
+        process.env.SENDER_EMAIL_3 || "",
+        process.env.SENDER_EMAIL_4 || "",
+        process.env.SENDER_EMAIL_5 || "",
+      ],
+      subject: "Pulse Report " + new Date().toLocaleString(),
+      html: htmlContent,
+      attachments: [
+        {
+          filename: `report.html`,
+          path: `${reportDir}/playwright-pulse-static-report.html`, // Attach the zipped folder
+        },
+      ],
+    };
+
+    // Send email
+    const info = await secureTransporter.sendMail(mailOptions);
+    console.log("Email sent: ", info.response);
+  } catch (error) {
+    console.error("Error sending email: ", error);
+  }
+};
+
+async function fetchCredentials(retries = 6) {
+  const timeout = 10000; // 10 seconds timeout
+  const key = getUUID();
+  // Validate API key exists before making any requests
+  if (!key) {
+    console.error(
+      "🔴 Critical: API key not provided - please set EMAIL_KEY in your environment variables"
+    );
+    console.warn("🟠 Falling back to default credentials (if any)");
+    return null; // Return null instead of throwing
+  }
+
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      console.log(`🟡 Attempt ${attempt} of ${retries}`);
+
+      // Create a timeout promise
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Request timed out after ${timeout}ms`));
+        }, timeout);
+      });
+
+      // Create the fetch promise
+      const fetchPromise = fetch(
+        "https://test-dashboard-66zd.onrender.com/api/getcredentials",
+        {
+          method: "GET",
+          headers: {
+            "x-api-key": `${key}`,
+          },
+        }
+      );
+
+      // Race between fetch and timeout
+      const response = await Promise.race([fetchPromise, timeoutPromise]);
+
+      if (!response.ok) {
+        // Handle specific HTTP errors with console messages only
+        if (response.status === 401) {
+          console.error("🔴 Invalid API key - authentication failed");
+        } else if (response.status === 404) {
+          console.error("🔴 Endpoint not found - check the API URL");
+        } else {
+          console.error(`🔴 Fetch failed with status: ${response.status}`);
+        }
+        continue; // Skip to next attempt instead of throwing
+      }
+
+      const data = await response.json();
+
+      // Validate the response structure
+      if (!data.username || !data.password) {
+        console.error("🔴 Invalid credentials format received from API");
+        continue;
+      }
+
+      console.log("🟢 Fetched credentials successfully");
+      return data;
+    } catch (err) {
+      console.error(`🔴 Attempt ${attempt} failed: ${err.message}`);
+
+      if (attempt === retries) {
+        console.error(
+          `🔴 All ${retries} attempts failed. Last error: ${err.message}`
+        );
+        console.warn(
+          "🟠 Proceeding without credentials - email sending will be skipped"
+        );
+        return null;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  }
+}
+
+// Main function to zip the folder and send the email
+const main = async () => {
+  await import("node-fetch").then((module) => {
+    fetch = module.default;
+  });
+  const credentials = await fetchCredentials();
+  if (!credentials) {
+    console.warn("Skipping email sending due to missing credentials");
+    // Continue with pipeline without failing
+    return;
+  }
+  await delay(10000);
+  try {
+    await sendEmail(credentials);
+  } catch (error) {
+    console.error("Error in main function: ", error);
+  }
+};
+
+main();