haven-cypress-integration 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haven-cypress-integration",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Seamless Cypress integration with HAVEN test case management",
   "main": "index.js",
   "bin": {

package/templates/run-filtered.sh

@@ -243,6 +243,13 @@ if [ -f "${REPORT_HTML}" ]; then
   cp "${REPORT_HTML}" "/shared/test-logs/report.html" || echo "Failed to copy HTML to shared volume"
 fi
 
+# Copy raw mochawesome reports for EC2 host to upload
+if [ -d "${MOCHAWESOME_DIR}" ]; then
+  echo "Copying mochawesome reports to shared volume for EC2 upload..."
+  mkdir -p /shared/mochawesome-report
+  cp -r "${MOCHAWESOME_DIR}"/* /shared/mochawesome-report/ || echo "Failed to copy mochawesome reports"
+fi
+
 # Post results to HAVEN API
 echo "Running syncCypressResults.js"
 PLAN_ID="${PLAN_ID}" RUN_ID="${RUN_ID}" TEST_ENVIRONMENT="${TEST_ENVIRONMENT}" node /haven/syncCypressResults.js "${MERGED_JSON}" || echo "Result sync script finished with warnings"

package/templates/syncCypressResults.js

@@ -7,6 +7,51 @@ const automationCasesPath = "/shared/automation-cases.json";
 const postBaseUrlPath = "/shared/result-post-url.txt";
 const triggeredByPath = "/shared/triggered-by.txt";
 
+// 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 {
@@ -72,13 +117,35 @@ function parseMochawesomeJson(jsonPath) {
     }
   }
 
-  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
@@ -86,8 +153,38 @@ function parseMochawesomeJson(jsonPath) {
             ? test.title.join(" ")
             : test.title;
 
-      // Extract automation IDs from title
-      const automationIdMatch = titleCombined.match(/@?TC-AUTO-[\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
@@ -104,7 +201,7 @@ function parseMochawesomeJson(jsonPath) {
     });
   }
 
-  (combinedResults.results || []).forEach(walkSuites);
+  (combinedResults.results || []).forEach(suite => walkSuites(suite, null));
   return { results, foundIds };
 }