k6-cucumber-steps 1.0.40 → 1.1.1

package/.vscode/settings.json

@@ -8,5 +8,6 @@
   "cucumber.glue": [
     "step_definitions/*.js",
     "src/features/stepDefinitions/*.js"
-  ]
+  ],
+  "liveServer.settings.port": 5501
 }

package/bin/k6-cucumber-steps.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-
+//bin/k6-cucumber-steps.js
 const path = require("path");
 const fs = require("fs");
 const { spawn } = require("child_process");
 const yargs = require("yargs");
 require("dotenv").config();
+const { generateHtmlReports } = require("../scripts/generateHtmlReports");
+const { linkReports } = require("../scripts/linkReports");
 
 console.log(`
   -----------------------------------------
@@ -95,9 +97,32 @@ if (configOptions.require && Array.isArray(configOptions.require)) {
 
 // Determine base report name
 const reportsDir = path.join(process.cwd(), "reports");
+// Clean and prepare reports directory
+const cleanReportsDir = () => {
+  if (fs.existsSync(reportsDir)) {
+    try {
+      fs.rmSync(reportsDir, { recursive: true, force: true });
+      console.log("🧹 Cleaned existing reports directory.");
+    } catch (err) {
+      console.error("❌ Failed to clean reports directory:", err.message);
+      process.exit(1);
+    }
+  }
+
+  try {
+    fs.mkdirSync(reportsDir, { recursive: true });
+    console.log("📁 Created fresh reports directory.");
+  } catch (err) {
+    console.error("❌ Failed to create reports directory:", err.message);
+    process.exit(1);
+  }
+};
+
+cleanReportsDir();
+
 const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
 
-let baseReportName = "load-results";
+let baseReportName = "load-report";
 if (featureFiles.length === 1) {
   const nameFromFeature = path.basename(featureFiles[0], ".feature");
   baseReportName = nameFromFeature || baseReportName;
@@ -145,12 +170,30 @@ const cucumberProcess = spawn("npx", cucumberArgs, {
 });
 
 cucumberProcess.on("close", (code) => {
-  console.log(`\n-----------------------------------------`);
   if (code === 0) {
+    console.log("-----------------------------------------");
     console.log("✅ k6-cucumber-steps execution completed successfully.");
+
+    generateHtmlReports(); // Cucumber HTML
+    console.log(
+      "🚀 Cucumber HTML report reports/cucumber-report.html generated successfully 👍"
+    );
+
+    const k6ReportPath = detectMostRecentK6Report(); // Add this helper function
+    if (k6ReportPath) {
+      console.log(
+        `📄 K6 HTML report ${k6ReportPath} generated successfully 👍`
+      );
+    }
+
+    linkReports(); // Link both reports
+
+    console.log("-----------------------------------------");
   } else {
+    console.error("-----------------------------------------");
     console.error("❌ k6-cucumber-steps execution failed.");
+    console.error("-----------------------------------------");
   }
-  console.log(`-----------------------------------------\n`);
+
   process.exit(code);
 });

package/cucumber.js

@@ -1,15 +1,15 @@
 module.exports = {
   default: {
-    require: ["./step_definitions/**/*.js"],
+    // require: ["./step_definitions/**/*.js"],
     format: [
       "summary",
-      "json:./src/examples/reports/load-report.json",
-      "html:./src/examples/reports/report.html",
+      "json:./reports/load-report.json",
+      "html:./reports/cucumber-report.html",
     ],
-    paths: ["./src/examples/features/loadTestTemplate.feature"],
-    tags: process.env.TAGS,
+    paths: ["./features/bsp.feature"],
+    tags: "@load",
     worldParameters: {
-      payloadPath: "apps/qa/performance/payloads",
+      payloadPath: "src/examples/payloads",
     },
     overwrite: true,
     reporter: true,

package/lib/helpers/buildK6Script.js

@@ -1,14 +1,12 @@
 module.exports = function buildK6Script(config) {
   const { method, endpoints, endpoint, body, headers, options } = config;
 
-  // Ensure at least one of `endpoints` or `endpoint` is defined
   if (!endpoints?.length && !endpoint) {
     throw new Error(
       'Either "endpoints" or "endpoint" must be defined in the configuration.'
     );
   }
 
-  // Prefer API_BASE_URL, fallback to BASE_URL
   const BASE_URL = process.env.API_BASE_URL || process.env.BASE_URL;
   if (!BASE_URL) {
     throw new Error(
@@ -16,53 +14,66 @@ module.exports = function buildK6Script(config) {
     );
   }
 
-  // Resolve relative endpoints by prepending BASE_URL
   const resolveEndpoint = (url) => {
     return url.startsWith("/") ? `${BASE_URL}${url}` : url;
   };
 
+  const stringifiedHeaders = JSON.stringify(headers, null, 2);
+  const stringifiedBody = JSON.stringify(body, null, 2);
+
   return `
 import http from 'k6/http';
 import { check } from 'k6';
+import { htmlReport } from "https://raw.githubusercontent.com/benc-uk/k6-reporter/main/dist/bundle.js";
+import { textSummary } from "https://jslib.k6.io/k6-summary/0.0.1/index.js";
 
 export const options = ${JSON.stringify(options, null, 2)};
 
 export default function () {
+  const headers = ${stringifiedHeaders};
+  const body = ${stringifiedBody};
+
   ${
     endpoints?.length
       ? endpoints
           .map(
             (url, i) => `
-    const resolvedUrl${i} = "${resolveEndpoint(url)}";
-    const res${i} = http.request("${method}", resolvedUrl${i}, ${
+  const resolvedUrl${i} = "${resolveEndpoint(url)}";
+  const res${i} = http.request("${method}", resolvedUrl${i}, ${
               method === "GET" || method === "DELETE"
                 ? "null"
-                : JSON.stringify(body)
-            }, {
-      headers: ${JSON.stringify(headers, null, 2)}
-    });
-    console.log(\`Response Body for \${resolvedUrl${i}}: \${res${i}.body}\`);
-    check(res${i}, {
-      "status is 2xx": (r) => r.status >= 200 && r.status < 300
-    });
+                : "JSON.stringify(body)"
+            }, { headers });
+  console.log(\`Response Body for \${resolvedUrl${i}}: \${res${i}.body}\`);
+  check(res${i}, {
+    "status is 2xx": (r) => r.status >= 200 && r.status < 300
+  });
   `
           )
           .join("\n")
       : `
-    const resolvedUrl = "${resolveEndpoint(endpoint)}";
-    const res = http.request("${method}", resolvedUrl, ${
+  const resolvedUrl = "${resolveEndpoint(endpoint)}";
+  const res = http.request("${method}", resolvedUrl, ${
           method === "GET" || method === "DELETE"
             ? "null"
-            : JSON.stringify(body)
-        }, {
-      headers: ${JSON.stringify(headers, null, 2)}
-    });
-    console.log(\`Response Body for \${resolvedUrl}: \${res.body}\`);
-    check(res, {
-      "status is 2xx": (r) => r.status >= 200 && r.status < 300
-    });
+            : "JSON.stringify(body)"
+        }, { headers });
+  console.log(\`Response Body for \${resolvedUrl}: \${res.body}\`);
+  check(res, {
+    "status is 2xx": (r) => r.status >= 200 && r.status < 300
+  });
   `
   }
 }
-  `;
+
+export function handleSummary(data) {
+  const outputDir = __ENV.REPORT_OUTPUT_DIR || "reports";
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const filename = \`\${outputDir}/k6-report-\${timestamp}.html\`;
+  return {
+    [filename]: htmlReport(data),
+    stdout: textSummary(data, { indent: " ", enableColors: true }),
+  };
+}
+`;
 };

package/lib/utils/k6Runner.js

@@ -60,46 +60,43 @@ const runK6Script = async (scriptPath, overwrite = false) => {
   const customLogo = `${chalkGreen} with @qaPaschalE's ${chalkYellow}k6-cucumber-steps v${packageJson.version}${resetColor}`;
 
   return new Promise(async (resolve, reject) => {
-    exec(
-      `k6 run --vus 1 --iterations 1 "${scriptPath}"`,
-      async (error, stdout, stderr) => {
-        // Split the k6 logo lines
-        const logoLines = stdout.split("\n");
+    exec(`k6 run "${scriptPath}"`, async (error, stdout, stderr) => {
+      // Split the k6 logo lines
+      const logoLines = stdout.split("\n");
 
-        // Insert the custom logo under "Grafana" (on the third line)
-        let modifiedStdout = "";
-        for (let i = 0; i < logoLines.length; i++) {
-          modifiedStdout += logoLines[i];
-          if (i === 5) {
-            // Target the third line (index 2) of the k6 logo
-            modifiedStdout += `   ${customLogo}\n`;
-          }
-          modifiedStdout += "\n";
-        }
-
-        // Handle errors and cleanup
-        if (error) {
-          console.error("k6 error:", error);
-          console.error("k6 stdout:", modifiedStdout);
-          await delay(3000); // Wait for 3 seconds
-          console.error("k6 stderr:", stderr);
-          reject(new Error(`k6 test execution failed: ${error.message}`));
-        } else if (stderr) {
-          console.log("k6 stdout:", modifiedStdout);
-          await delay(3000); // Wait for 3 seconds
-          resolve(stdout);
-        } else {
-          console.log("k6 stdout:", modifiedStdout);
-          await delay(3000); // Wait for 3 seconds
-          resolve(stdout);
+      // Insert the custom logo under "Grafana" (on the third line)
+      let modifiedStdout = "";
+      for (let i = 0; i < logoLines.length; i++) {
+        modifiedStdout += logoLines[i];
+        if (i === 5) {
+          // Target the third line (index 2) of the k6 logo
+          modifiedStdout += `   ${customLogo}\n`;
         }
+        modifiedStdout += "\n";
+      }
 
-        // Clean up the temporary script file
-        fs.unlink(scriptPath).catch((err) =>
-          console.error("Error deleting temporary k6 script:", err)
-        );
+      // Handle errors and cleanup
+      if (error) {
+        console.error("k6 error:", error);
+        console.error("k6 stdout:", modifiedStdout);
+        await delay(3000); // Wait for 3 seconds
+        console.error("k6 stderr:", stderr);
+        reject(new Error(`k6 test execution failed: ${error.message}`));
+      } else if (stderr) {
+        console.log("k6 stdout:", modifiedStdout);
+        await delay(3000); // Wait for 3 seconds
+        resolve(stdout);
+      } else {
+        console.log("k6 stdout:", modifiedStdout);
+        await delay(3000); // Wait for 3 seconds
+        resolve(stdout);
       }
-    );
+
+      // Clean up the temporary script file
+      fs.unlink(scriptPath).catch((err) =>
+        console.error("Error deleting temporary k6 script:", err)
+      );
+    });
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k6-cucumber-steps",
-  "version": "1.0.40",
+  "version": "1.1.1",
   "main": "index.js",
   "license": "MIT",
   "repository": {

package/scripts/generateHtmlReports.js

@@ -0,0 +1,53 @@
+const fs = require("fs");
+const path = require("path");
+const reporter = require("cucumber-html-reporter");
+
+function getJsonReportPath() {
+  // 1. Check for cucumber.js or custom config
+  const configFile = path.resolve("cucumber.js");
+  if (fs.existsSync(configFile)) {
+    const configText = fs.readFileSync(configFile, "utf-8");
+
+    const match = configText.match(/json:(.*?\.json)/);
+    if (match && match[1]) {
+      const reportPath = match[1].trim().replace(/['"`]/g, "");
+      console.log(`📝 Found report path in cucumber.js: ${reportPath}`);
+      return reportPath;
+    }
+  }
+
+  // 2. Check environment variable
+  if (process.env.CUCUMBER_JSON) {
+    console.log(
+      `📝 Using report path from CUCUMBER_JSON: ${process.env.CUCUMBER_JSON}`
+    );
+    return process.env.CUCUMBER_JSON;
+  }
+
+  // 3. Fallback to default
+  console.log("📝 Using default report path: reports/load-report.json");
+  return "reports/load-report.json";
+}
+
+function generateHtmlReports() {
+  const jsonReportPath = getJsonReportPath();
+
+  if (!fs.existsSync(jsonReportPath)) {
+    console.warn(`⚠️ Cucumber JSON report not found at: ${jsonReportPath}`);
+    return;
+  }
+
+  const reportDir = path.dirname(jsonReportPath);
+
+  reporter.generate({
+    theme: "bootstrap",
+    jsonFile: jsonReportPath,
+    output: path.join(reportDir, "cucumber-report.html"),
+    reportSuiteAsScenarios: true,
+    launchReport: false,
+    name: "k6-cucumber-steps Performance Report",
+    brandTitle: "📊 Performance Test Summary",
+  });
+}
+
+module.exports = { generateHtmlReports };

package/scripts/linkReports.js

@@ -0,0 +1,60 @@
+const fs = require("fs");
+const path = require("path");
+
+const reportsDir = path.resolve("reports");
+
+/**
+ * Adds internal cross-links between reports.
+ */
+function addLinksToReport(targetFile, otherFiles) {
+  const content = fs.readFileSync(targetFile, "utf-8");
+
+  // Inject the Cucumber Report tab before the Request Metrics tab
+  const cucumberTab = `
+    <input type="radio" name="tabs" id="tabcucumber">
+    <label for="tabcucumber"><i class="fas fa-file-alt"></i> &nbsp; Cucumber Report</label>
+    <div class="tab">
+      <iframe src="cucumber-report.html" style="width:100%; height:600px; border:none;"></iframe>
+    </div>
+  `;
+
+  const modifiedContent = content
+    .replace(
+      /<input type="radio" name="tabs" id="tabone"/,
+      `${cucumberTab}\n<input type="radio" name="tabs" id="tabone"`
+    )
+    // Remove standalone links to cucumber-report.html or k6-report.html
+    .replace(
+      /<div style="padding:10px;margin-top:20px;text-align:center">[\s\S]*?View (Cucumber|k6).*?<\/div>/,
+      ""
+    );
+
+  fs.writeFileSync(targetFile, modifiedContent, "utf-8");
+}
+
+/**
+ * Auto-link all HTML reports in the reports directory.
+ */
+function linkReports() {
+  if (!fs.existsSync(reportsDir)) {
+    console.warn("⚠️ No reports directory found.");
+    return;
+  }
+
+  const htmlFiles = fs
+    .readdirSync(reportsDir)
+    .filter((f) => f.endsWith(".html"))
+    .map((f) => path.join(reportsDir, f));
+
+  if (htmlFiles.length < 2) {
+    console.warn("⚠️ Not enough HTML files to link.");
+    return;
+  }
+
+  for (const file of htmlFiles) {
+    const others = htmlFiles.filter((f) => f !== file);
+    addLinksToReport(file, others);
+  }
+}
+
+module.exports = { linkReports };

package/step_definitions/load_test_steps.js

@@ -35,26 +35,56 @@ Given("I set a k6 script for {word} testing", function (method) {
  * When I set to run the k6 script with the following configurations:
  * | virtual_users | duration | http_req_failed | http_req_duration | error_rate | stages                                                              |
  * | 10            | 5        | rate<0.05       | p(95)<200         |            |                                                                     |
- * | 50            | 10       |                 |                   | rate<0.01  | [{"target": 10, "duration": "10s"}, {"target": 50, "duration": "30s"}] |
+ * | 50            | 10       | rate<0.01       |                   | rate<0.01  | [{"target": 10, "duration": "10s"}, {"target": 50, "duration": "30s"}] |
  */
 When(
   "I set to run the k6 script with the following configurations:",
   function (dataTable) {
-    const row = dataTable.hashes()[0];
+    const rawRow = dataTable.hashes()[0];
+    const row = {};
+
+    // Extract example values manually from this.pickle
+    const exampleMap = {};
+    if (this.pickle && this.pickle.astNodeIds && this.gherkinDocument) {
+      const scenario = this.gherkinDocument.feature.children.find((child) => {
+        return child.scenario && child.scenario.examples?.length;
+      });
+
+      const exampleValues =
+        scenario?.scenario?.examples?.[0]?.tableBody?.[0]?.cells?.map(
+          (cell) => cell.value
+        ) || [];
+
+      const exampleKeys =
+        scenario?.scenario?.examples?.[0]?.tableHeader?.cells?.map(
+          (cell) => cell.value
+        ) || [];
+
+      exampleKeys.forEach((key, idx) => {
+        exampleMap[key] = exampleValues[idx];
+      });
+    }
+
+    for (const [key, value] of Object.entries(rawRow)) {
+      row[key] = value.replace(/<([^>]+)>/g, (_, param) => {
+        return exampleMap[param] || value;
+      });
+    }
+
+    console.log("🚨 Resolved config row:", row);
 
-    // Validate thresholds only if they are not placeholders
-    const validateIfNotPlaceholder = (value) => {
-      if (value && !/^<.*>$/.test(value)) {
-        validateThreshold(value);
+    const validateThreshold = (value) => {
+      const regex = /^[\w{}()<>:]+[<>=]\d+(\.\d+)?$/;
+      if (value && !regex.test(value)) {
+        throw new Error(`Invalid threshold format: ${value}`);
       }
     };
 
-    validateIfNotPlaceholder(row.http_req_failed);
-    validateIfNotPlaceholder(row.http_req_duration);
-    validateIfNotPlaceholder(row.error_rate);
+    validateThreshold(row.http_req_failed);
+    validateThreshold(row.http_req_duration);
+    validateThreshold(row.error_rate);
 
     if (row.stages) {
-      // User provided a stages definition (JSON array)
       try {
         this.config.options = {
           stages: JSON.parse(row.stages),
@@ -63,11 +93,10 @@ When(
             http_req_duration: [row.http_req_duration],
           },
         };
-      } catch (err) {
+      } catch {
         throw new Error("Invalid stages JSON format.");
       }
     } else {
-      // Default to VUs and duration
       this.config.options = {
         vus: parseInt(row.virtual_users),
         duration: `${row.duration}s`,
@@ -78,7 +107,7 @@ When(
       };
     }
 
-    if (row.error_rate && !/^<.*>$/.test(row.error_rate)) {
+    if (row.error_rate) {
       this.config.options.thresholds.error_rate = [row.error_rate];
     }
   }
@@ -171,14 +200,11 @@ When(
     });
 
     this.config = {
+      ...this.config, // ✅ Keep previously set options!
       method: methodUpper,
       endpoint,
       body: resolved,
       headers: this.config?.headers || {},
-      options: {
-        vus: 1,
-        iterations: 1,
-      },
     };
 
     this.lastRequest = {

package/step_definitions/world.js

@@ -1,16 +1,39 @@
 const { setWorldConstructor } = require("@cucumber/cucumber");
 
 class CustomWorld {
-  constructor({ parameters }) {
+  constructor({ parameters, pickle }) {
     this.options = {};
     this.configurations = {};
     this.endpoints = [];
     this.authType = "";
     this.postBody = {};
+    this.aliases = {};
+    this.lastRequest = null;
+    this.lastResponse = null;
+
     this.overwrite =
       parameters?.overwrite ||
       process.env.K6_CUCUMBER_OVERWRITE === "true" ||
       false;
+
+    // ✅ Store scenario example values from <placeholders>
+    this.parameters = {};
+
+    if (parameters) {
+      this.parameters = { ...parameters };
+    }
+
+    if (pickle?.steps?.length) {
+      const matches = pickle.steps.flatMap((step) => {
+        return [...(step.text?.matchAll(/<([^>]+)>/g) || [])];
+      });
+      matches.forEach((match) => {
+        const key = match[1];
+        if (parameters?.[key]) {
+          this.parameters[key] = parameters[key];
+        }
+      });
+    }
   }
 }
 

package/.env.example

@@ -1,17 +0,0 @@
-# .env
-TEST_ENVIRONMENT=STAGING
-APP_VERSION=1.0.0
-BROWSER=Chrome 100.0.4896.88
-PLATFORM=Windows 10
-PARALLEL=Scenarios
-EXECUTED=Remote
-
-# Base URLs
-API_URL=https://test-api.example.com
-BASE_URL=https://example.com
-AUTH_URL=https://auth.example.com
-PAYMENT_URL=https://payment.example.com
-
-# Secret Parameters
-API_KEY=your-secret-api-key-12345
-BEARER_TOKEN=your_bearer_token_here

package/generateReport.js

@@ -1,24 +0,0 @@
-const reporter = require("cucumber-html-reporter");
-
-// Configuration for the HTML report
-const options = {
-  theme: "bootstrap", // You can change the theme to 'simple', 'compact', etc.
-  jsonFile: "reports/load-results.json", // Path to the JSON file generated by Cucumber
-  output: "reports/report.html", // Path where you want to save the HTML report
-  reportSuiteAsScenarios: true, // Group scenarios by their name
-  launchReport: true, // Automatically open the report in the browser
-  metadata: {
-    browser: {
-      name: "Chrome" || "unknown",
-      version: "89" || "unknown",
-    },
-    device: "Local test machine",
-    platform: {
-      name: "MacOS",
-      version: "20.04",
-    },
-  },
-};
-
-// Generate the report
-reporter.generate(options);