haven-cypress-integration 1.6.2 → 2.0.0

package/templates/syncCypressResults.js

@@ -1,66 +1,75 @@
-const fs = require("fs");
-const path = require("path");
-const axios = require("axios");
-const glob = require("glob");
-// AWS SDK removed - EC2 instance handles S3 uploads
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
 
-// Paths
+// Shared paths provided by HAVEN runner
 const automationCasesPath = "/shared/automation-cases.json";
 const postBaseUrlPath = "/shared/result-post-url.txt";
 const triggeredByPath = "/shared/triggered-by.txt";
-const baseUrl = fs.readFileSync(postBaseUrlPath, "utf-8").trim();
 
-// Read triggered_by value
+const baseUrl = fs.readFileSync(postBaseUrlPath, "utf-8").trim();
 let triggeredBy = null;
 try {
   if (fs.existsSync(triggeredByPath)) {
     triggeredBy = fs.readFileSync(triggeredByPath, "utf-8").trim();
   }
 } catch (err) {
-  console.warn("⚠️ Could not read triggered-by.txt:", err.message);
+  console.warn("Could not read triggered-by.txt:", err.message);
 }
 
-(async () => {
-  let automationIds = null;
-  const formatted = [];
-  const foundIds = new Set();
-
+function findJsonFiles(dir) {
+  const files = [];
   try {
-    const expectedCases = JSON.parse(
-      fs.readFileSync(automationCasesPath, "utf-8")
-    );
-    const ids = expectedCases
-      .map((c) => (c.automation_id || "").trim())
-      .filter(Boolean);
-    if (ids.length > 0) automationIds = new Set(ids);
+    const entries = fs.readdirSync(dir);
+    for (const entry of entries) {
+      if (entry.endsWith('.json')) {
+        files.push(path.join(dir, entry));
+      }
+    }
   } catch (err) {
-    console.warn(
-      "⚠️ No valid automation-cases.json found. Using @regression fallback."
-    );
+    console.error("Failed to read directory:", dir, err.message);
   }
+  return files;
+}
 
-  const mochawesomeDir = path.resolve("results/mochawesome");
-  console.log("Looking for mochawesome JSONs in:", `${mochawesomeDir}/*.json`);
-  const jsonFiles = glob.sync(`${mochawesomeDir}/*.json`);
+function parseMochawesomeJson(jsonPath) {
+  const results = [];
+  const foundIds = new Set();
+  let combinedResults = { results: [] };
 
-  if (jsonFiles.length === 0) {
-    console.error("❌ No mochawesome report files found.");
-    process.exit(1);
-  }
+  // If specific JSON path provided, use it
+  if (jsonPath && fs.existsSync(jsonPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+      if (data?.results) {
+        combinedResults.results.push(...data.results);
+      }
+    } catch (err) {
+      console.error("Failed to parse provided JSON:", err.message);
+    }
+  } else {
+    // Fallback: scan mochawesome directory
+    const mochawesomeDir = path.resolve("results/mochawesome");
+    console.log("Looking for mochawesome JSONs in:", `${mochawesomeDir}/*.json`);
+    const jsonFiles = findJsonFiles(mochawesomeDir);
+
+    if (jsonFiles.length === 0) {
+      console.error("No mochawesome report files found.");
+      return { results: [], foundIds: new Set() };
+    }
 
-  console.log(`📄 Found ${jsonFiles.length} mochawesome report(s).`);
-  const combinedResults = { results: [] };
+    console.log(`Found ${jsonFiles.length} mochawesome report(s).`);
 
-  try {
     for (const file of jsonFiles) {
-      const data = JSON.parse(fs.readFileSync(file, "utf-8"));
-      if (data?.results) {
-        combinedResults.results.push(...data.results);
+      try {
+        const data = JSON.parse(fs.readFileSync(file, "utf-8"));
+        if (data?.results) {
+          combinedResults.results.push(...data.results);
+        }
+      } catch (err) {
+        console.error("Failed to parse mochawesome JSON:", err.message);
       }
     }
-  } catch (err) {
-    console.error("❌ Failed to parse mochawesome JSON:", err.message);
-    process.exit(1);
   }
 
   function walkSuites(suite) {
@@ -77,7 +86,8 @@ try {
             ? test.title.join(" ")
             : test.title;
 
-      const allTags = [...(titleCombined.match(/@[\w-]+/g) || [])];
+      // Extract automation IDs from title
+      const automationIdMatch = titleCombined.match(/@?TC-AUTO-[\w.-]+/g) || [];
 
       const status =
         test.state === "passed" || test.pass === true
@@ -86,140 +96,110 @@ try {
             ? "skipped"
             : "fail";
 
-      if (!automationIds) {
-        allTags
-          .filter((tag) => /^TC-AUTO-\w+$/i.test(tag))
-          .forEach((tag) => {
-            formatted.push({ automation_id: tag, status });
-            foundIds.add(tag);
-          });
-      } else {
-        allTags
-          .filter((tag) => automationIds.has(tag))
-          .forEach((tag) => {
-            formatted.push({ automation_id: tag, status });
-            foundIds.add(tag);
-          });
-      }
+      automationIdMatch.forEach((tag) => {
+        const normalizedTag = tag.startsWith('@') ? tag : '@' + tag;
+        results.push({ automation_id: normalizedTag, status });
+        foundIds.add(normalizedTag.replace(/^@/, ''));
+      });
     });
   }
 
   (combinedResults.results || []).forEach(walkSuites);
+  return { results, foundIds };
+}
 
-  const notFound = automationIds
-    ? [...automationIds].filter((id) => !foundIds.has(id))
-    : [];
+async function postJson(url, payload) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(payload);
+    const urlObj = new URL(url);
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || 443,
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data)
+      }
+    };
 
-  const planId = process.env.PLAN_ID || "unknown";
-  const runId = process.env.RUN_ID || "unknown";
-  const testEnvironment = process.env.TEST_ENVIRONMENT || "QA";
+    const req = https.request(options, res => {
+      let body = '';
+      res.on('data', c => body += c);
+      res.on('end', () => resolve({ statusCode: res.statusCode, body }));
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
 
-  if (!planId || !runId || isNaN(Number(planId)) || isNaN(Number(runId))) {
-    console.error("❌ Invalid or missing PLAN_ID / RUN_ID");
-    process.exit(1);
-  }
+async function main() {
+  const planId = process.env.PLAN_ID || 'unknown_plan';
+  const runId = process.env.RUN_ID || 'unknown_run';
+  const testEnvironment = process.env.TEST_ENVIRONMENT || 'QA';
+  const jsonReportPath = process.argv[2];
 
-  await postResults(formatted, notFound, planId, runId, testEnvironment);
-  await postSummary(formatted, notFound, planId, runId, testEnvironment);
-})();
+  const { results: formattedResults, foundIds } = parseMochawesomeJson(jsonReportPath);
 
-async function postResults(formattedResults, notFoundList, planId, runId, testEnvironment) {
-  const postUrl = baseUrl; // baseUrl already includes the complete endpoint
-  console.log(`🔗 Posting to URL: ${postUrl}`);
+  console.log(`Looking for results in: ${jsonReportPath || 'results/mochawesome/*.json'}`);
+  console.log(`Found ${formattedResults.length} result(s).`);
 
+  // not_found from automation-cases.json (optional)
+  const normalizeId = (id) => id.replace(/^@/, '');
+  let notFoundList = [];
+  try {
+    const automationCases = JSON.parse(fs.readFileSync(automationCasesPath, 'utf-8'));
+    const expected = new Set((automationCases || []).map(a => normalizeId(a.automation_id)));
+    notFoundList = [...expected].filter(id => !foundIds.has(id));
+  } catch { }
+
+  // Post results
+  const resultsUrl = baseUrl;
   const payload = {
     planId,
     runId,
     environment: testEnvironment,
     results: formattedResults,
     not_found: notFoundList,
-    triggered_by: triggeredBy,
+    triggered_by: triggeredBy
   };
-
-  console.log(
-    "📤 Posting result from sync report:",
-    JSON.stringify(payload, null, 2)
-  );
+  console.log('Posting result payload:', JSON.stringify(payload, null, 2));
+  console.log(`Posting to URL: ${resultsUrl}`);
 
   try {
-    const response = await axios.post(postUrl, payload, {
-      headers: { "Content-Type": "application/json" },
-    });
-    console.log("✅ Test case results posted:", response.status);
-  } catch (err) {
-    console.error(
-      "❌ Failed to post test case results:",
-      err.response?.status,
-      err.response?.data || err.message
-    );
-    process.exit(1);
+    const res = await postJson(resultsUrl, payload);
+    console.log('Post status:', res.statusCode, res.body);
+  } catch (e) {
+    console.error('Failed to post results:', e.message);
   }
-}
 
-async function postSummary(results, notFound, planId, runId, testEnvironment) {
-  // Replace test-results with test-run-summary in the baseUrl
-  const url = baseUrl.replace('/api/test-results', '/api/test-run-summary');
+  // Post summary
+  const summaryUrl = baseUrl.replace('/api/test-results', '/api/test-run-summary');
+  const passedCount = formattedResults.filter(r => r.status === 'pass').length;
+  const failedCount = formattedResults.filter(r => r.status === 'fail').length;
+  const skippedCount = formattedResults.filter(r => r.status === 'skipped').length;
+  const overallStatus = failedCount > 0 ? 'failed' : (formattedResults.length > 0 ? 'completed' : 'no_tests');
 
-  const logs =
-    (await copyLogToShared(planId, runId)) || "Log copy failed or missing";
-
-  const summaryPayload = {
-    runId,
+  const summary = {
     planId,
+    runId,
     environment: testEnvironment,
-    status: computeOverallStatus(results, notFound),
-    logs,
-    result: {
-      total: results.length,
-      passed: results.filter((r) => r.status === "pass").length,
-      failed: results.filter((r) => r.status === "fail").length,
-      skipped: results.filter((r) => r.status === "skipped").length,
-      not_found: notFound.length,
-    },
+    status: overallStatus,
+    total: formattedResults.length,
+    passed: passedCount,
+    failed: failedCount,
+    skipped: skippedCount
   };
-
-  console.log("📤 Posting test run summary to:", url);
-  console.log("📦 Summary payload:", JSON.stringify(summaryPayload, null, 2));
+  console.log(`Posting summary to: ${summaryUrl}`);
+  console.log('Summary payload:', JSON.stringify(summary, null, 2));
 
   try {
-    const resp = await axios.post(url, summaryPayload, {
-      headers: { "Content-Type": "application/json" },
-    });
-    console.log("✅ Test run summary posted:", resp.data.message);
-  } catch (err) {
-    console.error(
-      "❌ Failed to post summary:",
-      err.response?.data || err.message
-    );
+    const res = await postJson(summaryUrl, summary);
+    console.log('Summary status:', res.statusCode, res.body);
+  } catch (e) {
+    console.error('Failed to post summary:', e.message);
   }
 }
 
-async function copyLogToShared(planId, runId) {
-  const logsPath = "results/logs.txt";
-
-  if (!fs.existsSync(logsPath)) {
-    console.warn("⚠️ No logs.txt file found to copy.");
-    return null;
-  }
-
-  const sharedDir = "/shared/test-logs";
-  if (!fs.existsSync(sharedDir)) {
-    fs.mkdirSync(sharedDir, { recursive: true });
-  }
-
-  try {
-    const destPath = path.join(sharedDir, "run_log.txt");
-    fs.copyFileSync(logsPath, destPath);
-    console.log(`📁 Logs copied to shared volume: ${destPath}`);
-    return destPath;
-  } catch (err) {
-    console.error("❌ Failed to copy log to shared volume:", err.message);
-    return null;
-  }
-}
-
-function computeOverallStatus(results, notFound) {
-  if (!results.length && !notFound.length) return "skipped";
-  const hasFail = results.some((r) => r.status === "fail");
-  return hasFail ? "failed" : "passed";
-}
+main().catch(e => { console.error(e); process.exit(1); });