haven-cypress-integration 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+# Haven-Cypress Integration
+
+Seamless integration between Cypress test frameworks and HAVEN test case management system.
+
+## Quick Start
+
+### 1. Install
+```bash
+npm install haven-cypress-integration
+```
+
+### 2. Add Tags to Tests
+Add `@TC-AUTO-XXXX` tags to your test descriptions:
+
+```javascript
+it("Login test @TC-AUTO-123, @p2", () => {
+  cy.visit('/login');
+  cy.get('[data-cy=username]').type('user');
+  cy.get('[data-cy=password]').type('pass');
+  cy.get('[data-cy=submit]').click();
+});
+
+it("User registration @TC-AUTO-124, @p1", () => {
+  cy.visit('/register');
+  // your test code
+});
+```
+
+### 3. Build Docker Image
+```bash
+npx haven-cypress build
+```
+
+### 4. Deploy to Haven
+Your Docker image is now ready to be deployed and run by HAVEN!
+
+## Commands
+
+### Build Image
+```bash
+# Basic build
+npx haven-cypress build
+
+# Custom tag
+npx haven-cypress build --tag=my-tests:v1.0
+
+# Build and push to registry
+npx haven-cypress build --tag=my-tests:v1.0 --push
+```
+
+### Run Tests
+```bash
+# Run all tests
+npx haven-cypress run
+
+# Run specific test cases
+npx haven-cypress run --automationIds=TC-AUTO-123,TC-AUTO-124
+```
+
+## What's Included
+
+- ✅ **Tag-based test filtering** (`@TC-AUTO-XXXX`)
+- ✅ **Mochawesome reporting** with screenshots
+- ✅ **S3 artifact upload** (reports, logs, screenshots)
+- ✅ **HAVEN API integration** (result synchronization)
+- ✅ **Docker containerization** ready for HAVEN deployment
+
+## How It Works
+
+1. **Haven runs your container** with mounted configuration and environment variables
+2. **Your tests run** with tag filtering based on automation IDs
+3. **Results are generated** using Mochawesome reporting
+4. **Artifacts are uploaded** to S3 for review
+5. **Results sync back** to HAVEN via API integration
+
+## Requirements
+
+- Node.js 14+
+- Docker
+- Existing Cypress project
+- HAVEN access credentials (provided by Haven when container runs)
+
+## Support
+
+For issues or questions, contact your HAVEN administrator.

package/bin/haven-cypress.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+const HavenCypressIntegration = require('../index.js');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (!command) {
+  console.log(`
+Haven-Cypress Integration
+
+Usage: npx haven-cypress <command> [options]
+
+Commands:
+  build [options]    Build Docker image with Haven integration
+  run [options]      Run tests with Haven integration
+
+Options:
+  --tag=name:version    Docker image tag (default: haven-cypress-tests:latest)
+  --push                Push image to registry after building
+  --automationIds=ID1,ID2  Run specific test cases
+
+Examples:
+  npx haven-cypress build
+  npx haven-cypress build --tag=my-tests:v1.0 --push
+  npx haven-cypress run --automationIds=TC-AUTO-123,TC-AUTO-124
+`);
+  process.exit(1);
+}
+
+const integration = new HavenCypressIntegration();
+
+// Parse options
+const options = {};
+args.slice(1).forEach(arg => {
+  if (arg.startsWith('--')) {
+    const [key, value] = arg.substring(2).split('=');
+    options[key] = value || true;
+  }
+});
+
+try {
+  switch (command) {
+    case 'build':
+      const tag = options.tag || 'haven-cypress-tests:latest';
+      integration.buildImage(tag, options);
+      break;
+      
+    case 'run':
+      const automationIds = options.automationIds || '';
+      integration.runTests(automationIds);
+      break;
+      
+    default:
+      console.error(`❌ Unknown command: ${command}`);
+      process.exit(1);
+  }
+} catch (error) {
+  console.error(`❌ Error: ${error.message}`);
+  process.exit(1);
+}

package/index.js

@@ -0,0 +1,146 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class HavenCypressIntegration {
+  constructor() {
+    this.templatesDir = path.join(__dirname, 'templates');
+  }
+
+  /**
+   * Build Docker image with Haven integration
+   * @param {string} tag - Docker image tag
+   * @param {Object} options - Build options
+   */
+  buildImage(tag = 'haven-cypress-tests:latest', options = {}) {
+    console.log('🐳 Building Haven-integrated Docker image...');
+    
+    // Create temporary build directory
+    const buildDir = path.join(process.cwd(), '.haven-build');
+    if (fs.existsSync(buildDir)) {
+      fs.rmSync(buildDir, { recursive: true });
+    }
+    fs.mkdirSync(buildDir, { recursive: true });
+    
+    try {
+      // Copy user's project files
+      console.log('📁 Copying project files...');
+      this.copyProjectFiles(buildDir);
+      
+      // Copy Haven integration files
+      console.log('🔧 Adding Haven integration files...');
+      this.copyHavenFiles(buildDir);
+      
+      // Build Docker image
+      console.log('🏗️ Building Docker image...');
+      execSync(`docker build -t ${tag} .`, { 
+        cwd: buildDir, 
+        stdio: 'inherit' 
+      });
+      
+      console.log(`✅ Docker image built successfully: ${tag}`);
+      
+      // Push if requested
+      if (options.push) {
+        console.log('📤 Pushing image to registry...');
+        execSync(`docker push ${tag}`, { stdio: 'inherit' });
+        console.log('✅ Image pushed successfully');
+      }
+      
+    } finally {
+      // Cleanup build directory
+      if (fs.existsSync(buildDir)) {
+        fs.rmSync(buildDir, { recursive: true });
+      }
+    }
+  }
+
+  /**
+   * Copy user's project files to build directory
+   */
+  copyProjectFiles(buildDir) {
+    const filesToCopy = [
+      'package.json',
+      'package-lock.json',
+      'cypress.config.js',
+      'cypress'
+    ];
+    
+    filesToCopy.forEach(file => {
+      const src = path.join(process.cwd(), file);
+      const dest = path.join(buildDir, file);
+      
+      if (fs.existsSync(src)) {
+        if (fs.statSync(src).isDirectory()) {
+          this.copyDir(src, dest);
+        } else {
+          fs.copyFileSync(src, dest);
+        }
+        console.log(`  ✅ Copied ${file}`);
+      } else {
+        console.log(`  ⚠️ Skipped ${file} (not found)`);
+      }
+    });
+  }
+
+  /**
+   * Copy Haven integration files to build directory
+   */
+  copyHavenFiles(buildDir) {
+    const havenFiles = [
+      'Dockerfile',
+      'run-filtered.sh',
+      'syncCypressResults.js'
+    ];
+    
+    havenFiles.forEach(file => {
+      const src = path.join(this.templatesDir, file);
+      const dest = path.join(buildDir, file);
+      
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+        console.log(`  ✅ Added ${file}`);
+      }
+    });
+    
+    // Make run-filtered.sh executable
+    execSync('chmod +x run-filtered.sh', { cwd: buildDir });
+  }
+
+  /**
+   * Copy directory recursively
+   */
+  copyDir(src, dest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+    
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      
+      if (entry.isDirectory()) {
+        this.copyDir(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Run tests with Haven integration
+   * This is called by Haven when the container runs
+   */
+  runTests(automationIds = '') {
+    console.log('🧪 Running Haven-integrated Cypress tests...');
+    console.log(`🔍 Automation IDs: ${automationIds || 'All tests'}`);
+    
+    // This will be handled by run-filtered.sh when container runs
+    // The library just provides the interface
+    return { success: true, message: 'Tests will run via run-filtered.sh' };
+  }
+}
+
+module.exports = HavenCypressIntegration;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "haven-cypress-integration",
+  "version": "1.0.0",
+  "description": "Seamless Cypress integration with HAVEN test case management",
+  "main": "index.js",
+  "bin": {
+    "haven-cypress": "./bin/haven-cypress.js"
+  },
+  "keywords": [
+    "cypress",
+    "haven",
+    "testing",
+    "integration",
+    "docker"
+  ],
+  "author": "BillExplainer",
+  "license": "ISC",
+  "files": [
+    "index.js",
+    "bin/",
+    "templates/"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/templates/Dockerfile

@@ -0,0 +1,29 @@
+FROM cypress/included:14.3.1
+
+WORKDIR /app
+
+# Copy project files
+COPY . .
+
+# ✅ Install zip and AWS CLI v2 via official method
+RUN apt-get update && \
+    apt-get install -y \
+    zip \
+    unzip \
+    curl && \
+    curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" && \
+    unzip awscliv2.zip && \
+    ./aws/install && \
+    rm -rf aws awscliv2.zip
+
+# ✅ Install Node deps
+RUN npm ci
+RUN npm install --no-save aws-sdk
+
+# ✅ Ensure script is executable
+COPY run-filtered.sh /app/run-filtered.sh
+RUN chmod +x /app/run-filtered.sh
+
+# ✅ Entrypoint
+ENTRYPOINT ["/app/run-filtered.sh"]
+CMD []

package/templates/run-filtered.sh

@@ -0,0 +1,129 @@
+#!/bin/bash
+
+echo "🔥 RUN SCRIPT:"
+echo "✅ ENTERED run-filtered.sh"
+echo "⚙️ Raw args: $@"
+
+# Extract automation IDs from CLI args
+AUTOMATION_IDS=""
+for arg in "$@"; do
+  case $arg in
+    --automationIds=*)
+      AUTOMATION_IDS="${arg#*=}"
+      shift
+      ;;
+  esac
+done
+
+echo "🔍 Extracted automation IDs: ${AUTOMATION_IDS}"
+echo "📂 Current working directory: $(pwd)"
+
+
+if [ -z "$AUTOMATION_IDS" ]; then
+  echo "🔁 No automation IDs provided. Running all tests..."
+  CYPRESS_GREP=""
+else
+  # Strip quotes from arg, replace commas with spaces
+  RAW_IDS=$(echo "$AUTOMATION_IDS" | sed "s/^['\"]//;s/['\"]$//")
+  CLEANED_IDS="${RAW_IDS//,/ }"
+
+  echo "🚀 Running Cypress with filtered tags: ${CLEANED_IDS}"
+  CYPRESS_GREP="--env grepTags='${CLEANED_IDS}'"
+fi
+
+# Set environment variables
+TIMESTAMP=$(date +%m%d%Y_%H%M%S)
+PRODUCT_NAME=${PRODUCT_NAME:-unknown_product}
+PLAN_ID=${PLAN_ID:-unknown_plan}
+RUN_ID=${RUN_ID:-unknown_run}
+BUCKET_NAME=${BUCKET_NAME:-your-default-bucket}
+
+# Ensure results directory exists
+mkdir -p results/mochawesome
+
+echo "🧹 Cleaning mochawesome reports"
+rm -rf results/mochawesome/*
+
+# Run Cypress
+echo "🚀 Running Cypress with filtered tags: ${AUTOMATION_IDS}"
+echo "💡 Final grep arg: $CYPRESS_GREP"
+eval "npx cypress run \
+  --headless \
+  --browser chrome \
+  $CYPRESS_GREP \
+  > results/logs.txt 2>&1"
+
+CYPRESS_EXIT_CODE=$?
+
+# Smart HTML report generation logic
+MOCHAWESOME_DIR="results/mochawesome"
+MERGED_JSON="results/results.json"
+REPORT_HTML="${MOCHAWESOME_DIR}/report.html"
+
+echo "🛠️ Attempting to merge mochawesome JSON files..."
+npx mochawesome-merge ${MOCHAWESOME_DIR}/*.json > "${MERGED_JSON}"
+
+if [ -s "${MERGED_JSON}" ]; then
+  echo "✅ Merge successful. Generating report from merged JSON."
+  npx marge "${MERGED_JSON}" --reportDir "${MOCHAWESOME_DIR}" --reportFilename report.html
+else
+  echo "⚠️ Merge failed or empty. Falling back to first mochawesome JSON file..."
+  FIRST_JSON=$(ls ${MOCHAWESOME_DIR}/*.json 2>/dev/null | head -n 1)
+  if [ -f "${FIRST_JSON}" ]; then
+    npx marge "${FIRST_JSON}" --reportDir "${MOCHAWESOME_DIR}" --reportFilename report.html
+  else
+    echo "❌ No valid mochawesome JSON file found for fallback."
+  fi
+fi
+
+# Copy screenshots (if any)
+SCREENSHOTS_DIR="cypress/screenshots"
+DEST_SCREENSHOTS_DIR="${MOCHAWESOME_DIR}/screenshots"
+if [ -d "$SCREENSHOTS_DIR" ]; then
+  echo "🖼️ Copying screenshots..."
+  mkdir -p "$DEST_SCREENSHOTS_DIR"
+  cp -r "$SCREENSHOTS_DIR"/* "$DEST_SCREENSHOTS_DIR" || echo "⚠️ No screenshots to copy"
+else
+  echo "ℹ️ No screenshots directory found."
+fi
+
+# Zip the mochawesome report
+ZIP_NAME="${PRODUCT_NAME}_${TIMESTAMP}.zip"
+ZIP_PATH="/tmp/${ZIP_NAME}"
+
+if [ -d "${MOCHAWESOME_DIR}" ]; then
+  echo "📦 Zipping mochawesome report and screenshots..."
+  zip -r "${ZIP_PATH}" "${MOCHAWESOME_DIR}" > /dev/null
+else
+  echo "❌ Mochawesome report folder not found: ${MOCHAWESOME_DIR}"
+fi
+
+# Upload zipped report to S3
+if [ -f "${ZIP_PATH}" ]; then
+  S3_BASE_KEY="artifact/${PLAN_ID}/automation/${RUN_ID}"
+  S3_ZIP_KEY="${S3_BASE_KEY}/${ZIP_NAME}"
+  echo "☁️ Uploading ZIP to s3://${BUCKET_NAME}/${S3_ZIP_KEY}"
+  aws s3 cp "${ZIP_PATH}" "s3://${BUCKET_NAME}/${S3_ZIP_KEY}" || echo "❌ S3 ZIP upload failed"
+else
+  echo "❌ No zip file to upload"
+fi
+
+# Upload HTML report file to S3
+if [ -f "${REPORT_HTML}" ]; then
+  HTML_NAME=$(basename "$REPORT_HTML")
+  S3_HTML_KEY="${S3_BASE_KEY}/${HTML_NAME}"
+  echo "🌐 Uploading HTML to s3://${BUCKET_NAME}/${S3_HTML_KEY}"
+  aws s3 cp "${REPORT_HTML}" "s3://${BUCKET_NAME}/${S3_HTML_KEY}" || echo "❌ S3 HTML upload failed"
+else
+  echo "❌ No HTML report found to upload"
+fi
+
+# Run result sync
+echo "🔄 Running syncCypressResults.js"
+PLAN_ID="${PLAN_ID}" RUN_ID="${RUN_ID}" node syncCypressResults.js >> results/logs.txt 2>&1 || echo "⚠️ syncCypressResults.js failed"
+
+# Final output
+echo "📤 Dumping results/logs.txt for runner capture:"
+cat results/logs.txt || echo "❌ Failed to read results/logs.txt"
+
+exit $CYPRESS_EXIT_CODE

package/templates/syncCypressResults.js

@@ -0,0 +1,218 @@
+const fs = require("fs");
+const path = require("path");
+const axios = require("axios");
+const glob = require("glob");
+const AWS = require("aws-sdk");
+
+// AWS setup
+const s3 = new AWS.S3({
+  region: process.env.AWS_REGION || "us-east-1",
+});
+const bucketName = process.env.S3_BUCKET || "your-bucket-name";
+
+// Paths
+const automationCasesPath = "/shared/automation-cases.json";
+const postBaseUrlPath = "/shared/result-post-url.txt";
+const baseUrl = fs.readFileSync(postBaseUrlPath, "utf-8").trim();
+
+(async () => {
+  let automationIds = null;
+  const formatted = [];
+  const foundIds = new Set();
+
+  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);
+  } catch (err) {
+    console.warn(
+      "⚠️ No valid automation-cases.json found. Using @regression fallback."
+    );
+  }
+
+  const mochawesomeDir = path.resolve("results/mochawesome");
+  console.log("Looking for mochawesome JSONs in:", `${mochawesomeDir}/*.json`);
+  const jsonFiles = glob.sync(`${mochawesomeDir}/*.json`);
+
+  if (jsonFiles.length === 0) {
+    console.error("❌ No mochawesome report files found.");
+    process.exit(1);
+  }
+
+  console.log(`📄 Found ${jsonFiles.length} mochawesome report(s).`);
+  const combinedResults = { results: [] };
+
+  try {
+    for (const file of jsonFiles) {
+      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);
+    process.exit(1);
+  }
+
+  function walkSuites(suite) {
+    collectTests(suite.tests);
+    (suite.suites || []).forEach(walkSuites);
+  }
+
+  function collectTests(tests) {
+    (tests || []).forEach((test) => {
+      const titleCombined =
+        typeof test.fullTitle === "string"
+          ? test.fullTitle
+          : Array.isArray(test.title)
+          ? test.title.join(" ")
+          : test.title;
+
+      const allTags = [...(titleCombined.match(/@[\w-]+/g) || [])];
+
+      const status =
+        test.state === "passed" || test.pass === true
+          ? "pass"
+          : test.pending === true
+          ? "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);
+          });
+      }
+    });
+  }
+
+  (combinedResults.results || []).forEach(walkSuites);
+
+  const notFound = automationIds
+    ? [...automationIds].filter((id) => !foundIds.has(id))
+    : [];
+
+  const planId = process.env.PLAN_ID || "unknown";
+  const runId = process.env.RUN_ID || "unknown";
+
+  if (!planId || !runId || isNaN(Number(planId)) || isNaN(Number(runId))) {
+    console.error("❌ Invalid or missing PLAN_ID / RUN_ID");
+    process.exit(1);
+  }
+
+  await postResults(formatted, notFound, planId, runId);
+  await postSummary(formatted, notFound, planId, runId);
+})();
+
+async function postResults(formattedResults, notFoundList, planId, runId) {
+  const postUrl = `${baseUrl}/api/test-results`;
+
+  const payload = {
+    planId,
+    runId,
+    results: formattedResults,
+    not_found: notFoundList,
+  };
+
+  console.log(
+    "📤 Posting result from sync report:",
+    JSON.stringify(payload, null, 2)
+  );
+
+  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);
+  }
+}
+
+async function postSummary(results, notFound, planId, runId) {
+  const url = `${baseUrl}/api/test-run-summary`;
+
+  const logs =
+    (await uploadLogToS3(planId, runId)) || "Log upload failed or missing";
+
+  const summaryPayload = {
+    runId,
+    planId,
+    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,
+    },
+  };
+
+  console.log("📤 Posting test run summary to:", url);
+  console.log("📦 Summary payload:", JSON.stringify(summaryPayload, 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
+    );
+  }
+}
+
+async function uploadLogToS3(planId, runId) {
+  const logsPath = "results/logs.txt";
+
+  if (!fs.existsSync(logsPath)) {
+    console.warn("⚠️ No logs.txt file found to upload.");
+    return null;
+  }
+
+  const key = `artifact/${planId}/automation/${runId}/run_log`;
+  const fileStream = fs.createReadStream(logsPath);
+
+  try {
+    await s3
+      .upload({
+        Bucket: bucketName,
+        Key: key,
+        Body: fileStream,
+        ContentType: "text/plain",
+      })
+      .promise();
+
+    return `s3://${bucketName}/${key}`;
+  } catch (err) {
+    console.error("❌ Failed to upload log to S3:", 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";
+}