haven-cypress-integration 1.6.2 → 2.0.1

package/templates/syncCypressResults.js

@@ -1,75 +1,151 @@
-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
+// Cache for spec file tag mappings
+const specTagsCache = new Map();
+
+/**
+ * Parse a Cypress spec file to extract test title -> automation ID mappings
+ * Looks for patterns like: it('Test title', { tags: ['@TC-AUTO-xxx'] }, () => {
+ */
+function parseSpecFileForTags(specFilePath) {
+  if (specTagsCache.has(specFilePath)) {
+    return specTagsCache.get(specFilePath);
+  }
+  
+  const titleToAutomationIds = new Map();
+  
+  try {
+    const content = fs.readFileSync(specFilePath, 'utf-8');
+    
+    // Match it() calls with tags - handles both single and double quotes
+    // Pattern: it('title' or it("title", { tags: [...] }
+    const itRegex = /it\s*\(\s*(['"`])([^'"`]+)\1\s*,\s*\{\s*tags\s*:\s*\[([^\]]+)\]/g;
+    
+    let match;
+    while ((match = itRegex.exec(content)) !== null) {
+      const testTitle = match[2];
+      const tagsStr = match[3];
+      
+      // Extract TC-AUTO tags from the tags array string
+      const automationIds = [];
+      const tagMatches = tagsStr.match(/@?TC-AUTO-[\w.-]+/g) || [];
+      tagMatches.forEach(tag => {
+        automationIds.push(tag.replace(/['"]/g, ''));
+      });
+      
+      if (automationIds.length > 0) {
+        titleToAutomationIds.set(testTitle, automationIds);
+      }
+    }
+  } catch (err) {
+    console.warn(`Could not parse spec file ${specFilePath}:`, err.message);
+  }
+  
+  specTagsCache.set(specFilePath, titleToAutomationIds);
+  return titleToAutomationIds;
+}
+
+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) {
-    collectTests(suite.tests);
-    (suite.suites || []).forEach(walkSuites);
+  function walkSuites(suite, specFilePath) {
+    // Get spec file path from suite or use passed-in path
+    const currentSpecPath = suite.fullFile || suite.file || specFilePath;
+    collectTests(suite.tests, currentSpecPath);
+    (suite.suites || []).forEach(s => walkSuites(s, currentSpecPath));
   }
 
-  function collectTests(tests) {
+  function collectTests(tests, specFilePath) {
+    // Get tag mappings from spec file if available
+    let specTagMap = new Map();
+    if (specFilePath) {
+      // Try multiple possible paths for the spec file
+      const possiblePaths = [
+        specFilePath,
+        path.resolve(specFilePath),
+        path.resolve('/app', specFilePath),
+        path.resolve(process.cwd(), specFilePath)
+      ];
+      
+      for (const tryPath of possiblePaths) {
+        if (fs.existsSync(tryPath)) {
+          specTagMap = parseSpecFileForTags(tryPath);
+          break;
+        }
+      }
+    }
+    
     (tests || []).forEach((test) => {
+      const testTitle = test.title;
       const titleCombined =
         typeof test.fullTitle === "string"
           ? test.fullTitle
@@ -77,7 +153,38 @@ try {
             ? test.title.join(" ")
             : test.title;
 
-      const allTags = [...(titleCombined.match(/@[\w-]+/g) || [])];
+      // Extract automation IDs from title first
+      let automationIdMatch = titleCombined.match(/@?TC-AUTO-[\w.-]+/g) || [];
+
+      // If not found in title, try looking up from spec file tags
+      if (automationIdMatch.length === 0 && specTagMap.has(testTitle)) {
+        automationIdMatch = specTagMap.get(testTitle);
+      }
+
+      // Also check mochawesome context for automation IDs (added via addContext)
+      if (test.context && automationIdMatch.length === 0) {
+        const contextArray = Array.isArray(test.context) ? test.context : [test.context];
+        for (const ctx of contextArray) {
+          if (ctx && ctx.title === 'automationIds' && Array.isArray(ctx.value)) {
+            automationIdMatch = ctx.value.filter(id => id.includes('TC-AUTO'));
+            break;
+          }
+          // Handle string context that might contain JSON
+          if (typeof ctx === 'string') {
+            try {
+              const parsed = JSON.parse(ctx);
+              if (parsed.title === 'automationIds' && Array.isArray(parsed.value)) {
+                automationIdMatch = parsed.value.filter(id => id.includes('TC-AUTO'));
+                break;
+              }
+            } catch (e) {
+              // Not JSON, check if it's a direct automation ID
+              const match = ctx.match(/@?TC-AUTO-[\w.-]+/g);
+              if (match) automationIdMatch = match;
+            }
+          }
+        }
+      }
 
       const status =
         test.state === "passed" || test.pass === true
@@ -86,140 +193,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);
+  (combinedResults.results || []).forEach(suite => walkSuites(suite, null));
+  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); });