k6-cucumber-steps 1.2.0 → 1.2.2

package/lib/helpers/buildK6Script.js

@@ -1,7 +1,6 @@
 module.exports = function buildK6Script(config) {
   const { method, endpoints, endpoint, body, headers, options, baseUrl } = config;
 
-  // Prefer baseUrl from config (set by step/world), then env
   const BASE_URL =
     baseUrl ||
     (config.worldParameters && config.worldParameters.baseUrl) ||
@@ -18,15 +17,19 @@ module.exports = function buildK6Script(config) {
     return url.startsWith("/") ? `${BASE_URL}${url}` : url;
   };
 
-  // Default headers/body/options for safety
   const safeHeaders = headers && Object.keys(headers).length ? headers : {};
   const safeBody = body !== undefined ? body : null;
   const safeOptions = options && Object.keys(options).length ? options : {};
 
-  // Stringify for script
   const stringifiedHeaders = JSON.stringify(safeHeaders, null, 2);
   const stringifiedBody = JSON.stringify(safeBody, null, 2);
 
+  const reportDir =
+    process.env.REPORT_OUTPUT_DIR ||
+    process.env.K6_REPORT_DIR ||
+    process.env.npm_config_report_output_dir ||
+    "reports";
+
   return `
 import http from 'k6/http';
 import { check } from 'k6';
@@ -50,7 +53,6 @@ export default function () {
                 ? "null"
                 : "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
   });
@@ -64,7 +66,6 @@ export default function () {
             ? "null"
             : "JSON.stringify(body)"
         }, { headers });
-  console.log(\`Response Body for \${resolvedUrl}: \${res.body}\`);
   check(res, {
     "status is 2xx": (r) => r.status >= 200 && r.status < 300
   });
@@ -73,24 +74,8 @@ export default function () {
 }
 
 export function handleSummary(data) {
-  const outputDir = __ENV.REPORT_OUTPUT_DIR || "reports";
-  const html = htmlReport(data);
-  const cucumberReportFile = "cucumber-report.html";
-  const cucumberLink = \`
-    <div style="text-align:center; margin-top:20px;">
-      <a href="\${cucumberReportFile}" style="font-size:18px; color:#0066cc;">
-        🔗 View Cucumber Test Report
-      </a>
-    </div>
-  \`;
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const k6ReportFilename = \`\${outputDir}/k6-report-\${timestamp}.html\`;
-
-  console.log(\`📄 K6 HTML report \${k6ReportFilename} generated successfully 👍\`);
-
   return {
-    [k6ReportFilename]: html.replace("</body>", \`\${cucumberLink}</body>\`),
+    "${reportDir}/k6-report.html": htmlReport(data),
     stdout: textSummary(data, { indent: " ", enableColors: true }),
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k6-cucumber-steps",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "main": "index.js",
   "license": "MIT",
   "repository": {
@@ -54,7 +54,7 @@
     "test-automation"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "author": "qaPaschalE",
   "description": "Cucumber step definitions for running k6 performance tests.",

package/step_definitions/load_test_steps.js

@@ -3,42 +3,27 @@
 const { Given, When, Then } = require("@cucumber/cucumber");
 const fs = require("fs");
 const path = require("path");
-const { execSync } = require("child_process");
 const resolveBody = require("../lib/helpers/resolveBody.js");
 const buildK6Script = require("../lib/helpers/buildK6Script.js");
 const generateHeaders = require("../lib/helpers/generateHeaders.js");
 const { generateK6Script, runK6Script } = require("../lib/utils/k6Runner.js");
+const os = require("os");
+const crypto = require("crypto");
 require("dotenv").config();
 
-// Validate thresholds (e.g., "rate<0.01")
-const validateThreshold = (threshold) => {
-  const regex = /^[\w{}()<>:]+[<>=]\d+(\.\d+)?$/;
-  if (!regex.test(threshold)) {
-    throw new Error(`Invalid threshold format: ${threshold}`);
-  }
-};
-
 /**
- * @param {string} method - HTTP method (e.g., GET, POST).
- * @example
- * Given I set a k6 script for GET testing
- * Given I set a k6 script for POST testing
+ * Sets the HTTP method for the k6 script.
  */
-Given("I set a k6 script for {word} testing", function (method) {
+Given(/^I set a k6 script for (\w+) testing$/, async function (method) {
   this.config = { method: method.toUpperCase() };
 });
 
 /**
- * @param {DataTable} dataTable - Table with configurations.
- * @example
- * 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       |                   | rate<0.01  | [{"target": 10, "duration": "10s"}, {"target": 50, "duration": "30s"}] |
+ * Sets k6 script options from a configuration table.
  */
 When(
-  "I set to run the k6 script with the following configurations:",
-  function (dataTable) {
+  /^I set to run the k6 script with the following configurations:$/,
+  async function (dataTable) {
     const rawRow = dataTable.hashes()[0];
     const row = {};
 
@@ -70,8 +55,6 @@ When(
       });
     }
 
-    console.log("🚨 Resolved config row:", row);
-
     const validateThreshold = (value) => {
       const regex = /^[\w{}()<>:]+[<>=]\d+(\.\d+)?$/;
       if (value && !regex.test(value)) {
@@ -113,35 +96,24 @@ When(
 );
 
 /**
- * @param {DataTable} dataTable - Table with header and value for request headers.
- * @example
- * When I set the request headers:
- * | Header        | Value                     |
- * | Content-Type  | application/json          |
- * | Authorization | Bearer your_auth_token    |
+ * Sets request headers for the k6 script.
  */
-When("I set the request headers:", function (dataTable) {
+When(/^I set the request headers:$/, async function (dataTable) {
   const headers = {};
   dataTable.hashes().forEach(({ Header, Value }) => {
     headers[Header] = Value;
   });
 
   this.config.headers = {
-    ...this.config.headers, // preserve auth headers if set
+    ...this.config.headers,
     ...headers,
   };
 });
 
 /**
- * @param {string} docString - Multiline string containing the endpoints.
- * @example
- * When I set the following endpoints used:
- * """
- * /api/users
- * /api/products
- * """
+ * Sets endpoints for the k6 script.
  */
-When("I set the following endpoints used:", function (docString) {
+When(/^I set the following endpoints used:$/, async function (docString) {
   this.config.endpoints = docString
     .trim()
     .split("\n")
@@ -149,30 +121,23 @@ When("I set the following endpoints used:", function (docString) {
 });
 
 /**
- * @param {string} method - HTTP method (e.g., POST, PUT).
- * @param {string} endpoint - The endpoint for the body.
- * @param {string} docString - Multiline string containing the request body (can use placeholders).
- * @example
- * When I set the following POST body is used for "/api/users"
- * """
- * {
- * "username": "{{username}}",
- * "email": "{{faker.internet.email}}"
- * }
- * """
+ * Sets the request body for a specific method and endpoint.
  */
 When(
-  "I set the following {word} body is used for {string}",
-  function (method, endpoint, docString) {
+  /^I set the following (\w+) body is used for "([^"]+)"$/,
+  async function (method, endpoint, docString) {
     this.config.method = method.toUpperCase();
     this.config.body = resolveBody(docString, process.env);
     this.config.endpoint = endpoint;
   }
 );
 
+/**
+ * Loads a JSON payload for a method and endpoint.
+ */
 When(
-  "I use JSON payload from {string} for {word} to {string}",
-  function (fileName, method, endpoint) {
+  /^I use JSON payload from "([^"]+)" for (\w+) to "([^"]+)"$/,
+  async function (fileName, method, endpoint) {
     const allowedMethods = ["POST", "PUT", "PATCH"];
     const methodUpper = method.toUpperCase();
 
@@ -188,7 +153,7 @@ When(
     const payloadDir = this.parameters?.payloadPath || "payloads";
     const payloadPath = path.isAbsolute(payloadDir)
       ? path.join(payloadDir, fileName)
-      : path.join(__dirname, "..", "..", payloadDir, fileName);
+      : path.join(projectRoot, payloadDir, fileName);
 
     if (!fs.existsSync(payloadPath)) {
       throw new Error(`Payload file not found: ${payloadPath}`);
@@ -201,7 +166,7 @@ When(
     });
 
     this.config = {
-      ...this.config, // ✅ Keep previously set options!
+      ...this.config,
       method: methodUpper,
       endpoint,
       body: resolved,
@@ -217,14 +182,9 @@ When(
 );
 
 /**
- * @param {string} authType - Authentication type (api_key, bearer_token, basic, none).
- * @example
- * When I set the authentication type to "bearer_token"
- * When I set the authentication type to "api_key"
- * When I set the authentication type to "basic"
- * When I set the authentication type to "none"
+ * Sets the authentication type for the request.
  */
-When("I set the authentication type to {string}", function (authType) {
+When(/^I set the authentication type to "([^"]+)"$/, async function (authType) {
   this.config.headers = generateHeaders(
     authType,
     process.env,
@@ -233,11 +193,11 @@ When("I set the authentication type to {string}", function (authType) {
 });
 
 /**
- * Then I store the value at "data.token" as alias "token"
+ * Stores a value from the last response as an alias.
  */
 Then(
-  "I store the value at {string} as alias {string}",
-  function (jsonPath, alias) {
+  /^I store the value at "([^"]+)" as alias "([^"]+)"$/,
+  async function (jsonPath, alias) {
     if (!this.lastResponse) {
       throw new Error("No previous response available.");
     }
@@ -260,20 +220,24 @@ Then(
     console.log(`🧩 Stored alias "${alias}":`, value);
   }
 );
+
+/**
+ * Logs in via POST to an endpoint with a payload from a file.
+ */
 When(
-  "I login via POST to {string} with payload from {string}",
+  /^I login via POST to "([^"]+)" with payload from "([^"]+)"$/,
   async function (endpoint, fileName) {
     const payloadDir = this.parameters?.payloadPath || "payloads";
+    const projectRoot = path.resolve(__dirname, "..", "..");
     const payloadPath = path.isAbsolute(payloadDir)
       ? path.join(payloadDir, fileName)
-      : path.join(__dirname, "..", "..", payloadDir, fileName);
+      : path.join(projectRoot, payloadDir, fileName);
 
     if (!fs.existsSync(payloadPath)) {
       throw new Error(`Payload file not found: ${payloadPath}`);
     }
 
     const rawTemplate = fs.readFileSync(payloadPath, "utf-8");
-
     const resolved = resolveBody(rawTemplate, {
       ...process.env,
       ...(this.aliases || {}),
@@ -295,7 +259,7 @@ When(
         throw new Error(`Login request failed with status ${response.status}`);
       }
 
-      this.lastResponse = data; // ✅ Makes aliasing work
+      this.lastResponse = data;
       console.log("🔐 Login successful, response saved to alias context.");
     } catch (err) {
       console.error("❌ Login request failed:", err.message);
@@ -304,15 +268,24 @@ When(
   }
 );
 
-/**
- * @param {string} method - HTTP method of the request.
- * @example
- * Then I see the API should handle the GET request successfully
- * Then I see the API should handle the POST request successfully
- */
+const genScriptDir = path.resolve(process.cwd(), "genScript");
+if (!fs.existsSync(genScriptDir)) {
+  fs.mkdirSync(genScriptDir, { recursive: true });
+}
+
+// Determine the report/output directory from env, CLI, or default to "reports"
+const reportDir =
+  process.env.REPORT_OUTPUT_DIR ||
+  process.env.K6_REPORT_DIR ||
+  (process.env.npm_config_report_output_dir || "reports");
+
+if (!fs.existsSync(reportDir)) {
+  fs.mkdirSync(reportDir, { recursive: true });
+}
+
 Then(
-  "I see the API should handle the {word} request successfully",
-  { timeout: 60000 },
+  /^I see the API should handle the (\w+) request successfully$/,
+  { timeout: 300000 },
   async function (method) {
     if (!this.config || !this.config.method) {
       throw new Error("Configuration is missing or incomplete.");
@@ -325,32 +298,46 @@ Then(
       );
     }
     try {
-      // Build the k6 script content
       const scriptContent = buildK6Script(this.config);
+      const uniqueId = crypto.randomBytes(8).toString("hex");
+      const scriptPath = path.join(reportDir, `k6-script-${uniqueId}.js`);
+      fs.writeFileSync(scriptPath, scriptContent, "utf-8");
+      console.log(`✅ k6 script generated at: ${scriptPath}`);
 
-      // Generate the k6 script file
-      const scriptPath = await generateK6Script(
-        scriptContent,
-        "load",
-        process.env.K6_CUCUMBER_OVERWRITE === "true"
-      );
-
-      // Run the k6 script and capture output
+      // Always run k6 automatically, regardless of VU count
       const { stdout, stderr, code } = await runK6Script(
         scriptPath,
         process.env.K6_CUCUMBER_OVERWRITE === "true"
       );
-
       if (stdout) console.log(stdout);
       if (stderr) console.error(stderr);
-
       if (code !== 0) {
         throw new Error(`k6 exited with code ${code}`);
       }
+
+      // Remove the script unless saveK6Script is true in env/config/cli
+      const saveK6Script =
+        process.env.saveK6Script === "true" ||
+        process.env.SAVE_K6_SCRIPT === "true" ||
+        this.parameters?.saveK6Script === true;
+
+      if (!saveK6Script) {
+        try {
+          fs.unlinkSync(scriptPath);
+        } catch (cleanupErr) {
+          console.warn(`Warning: Could not delete temp script file: ${scriptPath}`);
+        }
+      } else {
+        console.log(`ℹ️  k6 script kept at: ${scriptPath}`);
+      }
     } catch (error) {
-      // Print the full error for debugging
-      console.error("k6 execution failed:", error.stack || error);
-      throw new Error("k6 test execution failed");
+      console.error(
+        "Failed to generate or run k6 script:",
+        error.stack || error
+      );
+      throw new Error("k6 script generation or execution failed");
     }
   }
 );
+
+// Repeat this pattern for all other step definitions!

package/step_definitions/world.js

@@ -1,3 +1,4 @@
+//world.js
 const { setWorldConstructor } = require("@cucumber/cucumber");
 
 class CustomWorld {

package/scripts/generateHtmlReports.js

@@ -1,53 +0,0 @@
-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 };