@arghajit/dummy 0.1.0-beta-12 → 0.1.0-beta-14

package/scripts/{sendReport.js → sendReport.mjs}

@@ -1,21 +1,42 @@
 #!/usr/bin/env node
-const nodemailer = require("nodemailer");
-const path = require("path");
-const archiver = require("archiver");
-const fileSystem = require("fs");
-const reportDir = "./pulse-report";
+import nodemailer from "nodemailer"; // CHANGED
+import path from "path"; // CHANGED (already was, but good to be explicit)
+import archiver from "archiver"; // CHANGED
+import {
+  createWriteStream,
+  readFileSync as fsReadFileSync, // Renamed to avoid conflict if fs from fs/promises is used
+  existsSync as fsExistsSync, // Renamed
+} from "fs"; // CHANGED for specific functions
+import { fileURLToPath } from "url";
+import { fork } from "child_process"; // This was missing in your sendReport.js but present in generate-email-report.js and needed for runScript
+import "dotenv/config"; // CHANGED for dotenv
+
+// Import chalk using top-level await if your Node version supports it (14.8+)
+// or keep the dynamic import if preferred, but ensure chalk is resolved before use.
+let chalk;
+try {
+  chalk = (await import("chalk")).default;
+} catch (e) {
+  console.warn("Chalk could not be imported. Using plain console logs.");
+  chalk = {
+    green: (text) => text,
+    red: (text) => text,
+    yellow: (text) => text,
+    blue: (text) => text,
+    bold: (text) => text,
+    gray: (text) => text,
+  };
+}
 
-require("dotenv").config();
+const reportDir = "./pulse-report";
 
 let fetch;
-import("node-fetch")
-  .then((module) => {
-    fetch = module.default;
-  })
-  .catch((err) => {
-    console.error("Failed to import node-fetch:", err);
-    process.exit(1);
-  });
+// Ensure fetch is imported and available before it's used in fetchCredentials
+// Using a top-level import is generally cleaner:
+// import fetch from 'node-fetch';
+// However, your dynamic import pattern is also fine if `fetch` is awaited properly.
+// For simplicity, I'll assume the dynamic import is handled and awaited before fetchCredentials is called.
+// The existing dynamic import for fetch is okay.
 
 let projectName;
 
@@ -26,11 +47,12 @@ function getUUID() {
   );
   console.log("Report path:", reportPath);
 
-  if (!fileSystem.existsSync(reportPath)) {
+  if (!fsExistsSync(reportPath)) {
+    // CHANGED
     throw new Error("Pulse report file not found.");
   }
 
-  const content = JSON.parse(fileSystem.readFileSync(reportPath, "utf-8"));
+  const content = JSON.parse(fsReadFileSync(reportPath, "utf-8")); // CHANGED
   const idString = content.run.id;
   const parts = idString.split("-");
   const uuid = parts.slice(-5).join("-");
@@ -49,25 +71,25 @@ const formatStartTime = (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)) {
+  if (!fsExistsSync(reportPath)) {
+    // CHANGED
     throw new Error("Pulse report file not found.");
   }
 
-  const content = JSON.parse(fileSystem.readFileSync(reportPath, "utf-8"));
+  const content = JSON.parse(fsReadFileSync(reportPath, "utf-8")); // CHANGED
   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 durationInMs = run.duration || 0; // Keep in ms for formatDuration
 
   const readableStartTime = new Date(run.timestamp).toLocaleString();
 
@@ -80,37 +102,35 @@ const getPulseReportSummary = () => {
     failedPercentage: total ? ((failed / total) * 100).toFixed(2) : "0.00",
     skippedPercentage: total ? ((skipped / total) * 100).toFixed(2) : "0.00",
     startTime: readableStartTime,
-    duration: formatDuration(duration),
+    duration: formatDuration(durationInMs), // Pass ms to formatDuration
   };
 };
 
-// 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 } });
+    const output = createWriteStream(zipPath); // CHANGED
+    const archiveInstance = archiver("zip", { zlib: { level: 9 } }); // Renamed to avoid conflict
 
     output.on("close", () => {
-      console.log(`${archive.pointer()} total bytes`);
+      console.log(`${archiveInstance.pointer()} total bytes`);
       console.log("Folder has been zipped successfully.");
-      resolve(); // Resolve the promise after zipping is complete
+      resolve();
     });
 
-    archive.on("error", (err) => {
-      reject(err); // Reject the promise in case of an error
+    archiveInstance.on("error", (err) => {
+      reject(err);
     });
 
-    archive.pipe(output);
-    archive.directory(folderPath, false); // Zip the folder without the parent folder
-    archive.finalize(); // Finalize the archive
+    archiveInstance.pipe(output);
+    archiveInstance.directory(folderPath, false);
+    archiveInstance.finalize();
   });
 };
 
-// Function to convert JSON data to HTML table format
 const generateHtmlTable = (data) => {
-  projectName = "Pulse Emailable Report";
+  projectName = "Pulse Emailable Report"; // Consider passing projectName as an arg or making it a const
   const stats = data;
   const total = stats.passed + stats.failed + stats.skipped;
   const passedTests = stats.passed;
@@ -120,7 +140,7 @@ const generateHtmlTable = (data) => {
   const skippedTests = stats.skipped;
   const skippedPercentage = stats.skippedPercentage;
   const startTime = stats.startTime;
-  const durationSeconds = stats.duration;
+  const durationString = stats.duration; // Already formatted string
 
   return `
   <!DOCTYPE html>
@@ -161,8 +181,8 @@ const generateHtmlTable = (data) => {
           <td>${startTime}</td>
         </tr>
         <tr>
-          <td>Test Run Duration (Seconds)</td>
-          <td>${durationSeconds}</td>
+          <td>Test Run Duration</td> 
+          <td>${durationString}</td>
         </tr>
         <tr>
           <td>Total Tests Count</td>
@@ -183,32 +203,65 @@ const generateHtmlTable = (data) => {
       </tbody>
     </table>
     <p>With regards,</p>
-    <p>Networks QA Team</p>
+    <p>QA / SDET</p>
   </body>
   </html>
   `;
 };
 
-// Async function to send an email
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Ensure the name here matches the actual file name of input_file_0.js
+// If input_file_0.js is indeed the script, use that name.
+// Using .mjs extension explicitly tells Node to treat it as ESM.
+const archiveRunScriptPath = path.resolve(
+  __dirname,
+  "generate-email-report.mjs" // Or input_file_0.mjs if you rename it, or input_file_0.js if you configure package.json
+);
+
+async function runScript(scriptPath) {
+  return new Promise((resolve, reject) => {
+    const childProcess = fork(scriptPath, [], {
+      // Renamed variable
+      stdio: "inherit",
+    });
+
+    childProcess.on("error", (err) => {
+      console.error(chalk.red(`Failed to start script: ${scriptPath}`), err);
+      reject(err);
+    });
+
+    childProcess.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        const errorMessage = `Script ${scriptPath} exited with code ${code}.`;
+        console.error(chalk.red(errorMessage));
+        reject(new Error(errorMessage));
+      }
+    });
+  });
+}
+
 const sendEmail = async (credentials) => {
+  await runScript(archiveRunScriptPath);
   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
+      secure: true,
       auth: {
         user: credentials.username,
-        pass: credentials.password, // Ensure you use app password or secured token
+        pass: credentials.password,
       },
     });
-    // Generate HTML content for email
+
     const reportData = getPulseReportSummary();
     const htmlContent = generateHtmlTable(reportData);
 
-    // Configure mail options
     const mailOptions = {
       from: credentials.username,
       to: [
@@ -217,18 +270,18 @@ const sendEmail = async (credentials) => {
         process.env.SENDER_EMAIL_3 || "",
         process.env.SENDER_EMAIL_4 || "",
         process.env.SENDER_EMAIL_5 || "",
-      ],
+      ].filter((email) => email), // Filter out empty strings
       subject: "Pulse Report " + new Date().toLocaleString(),
       html: htmlContent,
       attachments: [
         {
           filename: `report.html`,
-          path: `${reportDir}/playwright-pulse-static-report.html`, // Attach the zipped folder
+          // Make sure this path is correct and the file is generated by archiveRunScriptPath
+          path: path.join(reportDir, "pulse-email-summary.html"),
         },
       ],
     };
 
-    // Send email
     const info = await secureTransporter.sendMail(mailOptions);
     console.log("Email sent: ", info.response);
   } catch (error) {
@@ -237,29 +290,39 @@ const sendEmail = async (credentials) => {
 };
 
 async function fetchCredentials(retries = 6) {
-  const timeout = 10000; // 10 seconds timeout
+  // Ensure fetch is initialized from the dynamic import before calling this
+  if (!fetch) {
+    try {
+      fetch = (await import("node-fetch")).default;
+    } catch (err) {
+      console.error(
+        "Failed to import node-fetch dynamically for fetchCredentials:",
+        err
+      );
+      return null;
+    }
+  }
+
+  const timeout = 10000;
   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"
+      "🔴 Critical: API key (UUID from report) not found or invalid."
     );
-    console.warn("🟠 Falling back to default credentials (if any)");
-    return null; // Return null instead of throwing
+    return null;
   }
 
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
-      console.log(`🟡 Attempt ${attempt} of ${retries}`);
+      console.log(`🟡 Attempt ${attempt} of ${retries} to fetch credentials`);
 
-      // 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",
         {
@@ -270,11 +333,9 @@ async function fetchCredentials(retries = 6) {
         }
       );
 
-      // 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) {
@@ -282,14 +343,17 @@ async function fetchCredentials(retries = 6) {
         } else {
           console.error(`🔴 Fetch failed with status: ${response.status}`);
         }
-        continue; // Skip to next attempt instead of throwing
+        if (attempt < retries)
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        continue;
       }
 
       const data = await response.json();
 
-      // Validate the response structure
       if (!data.username || !data.password) {
         console.error("🔴 Invalid credentials format received from API");
+        if (attempt < retries)
+          await new Promise((resolve) => setTimeout(resolve, 1000));
         continue;
       }
 
@@ -297,34 +361,37 @@ async function fetchCredentials(retries = 6) {
       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));
     }
   }
+  return null; // Should be unreachable if loop logic is correct
 }
 
-// Main function to zip the folder and send the email
 const main = async () => {
-  await import("node-fetch").then((module) => {
-    fetch = module.default;
-  });
+  // Ensure fetch is initialized (dynamic import at top or here)
+  if (!fetch) {
+    try {
+      fetch = (await import("node-fetch")).default;
+    } catch (err) {
+      console.error("Failed to import node-fetch at start of main:", err);
+      process.exit(1); // Or handle error appropriately
+    }
+  }
+
   const credentials = await fetchCredentials();
   if (!credentials) {
-    console.warn("Skipping email sending due to missing credentials");
-    // Continue with pipeline without failing
+    console.warn(
+      "Skipping email sending due to missing or failed credential fetch"
+    );
     return;
   }
-  await delay(10000);
+  // Removed await delay(10000); // If not strictly needed, remove it.
   try {
     await sendEmail(credentials);
   } catch (error) {