k6-cucumber-steps 1.0.39 → 1.0.41

package/.env.example

@@ -7,7 +7,7 @@ PARALLEL=Scenarios
 EXECUTED=Remote
 
 # Base URLs
-API_URL=https://test-api.example.com
+API_BASE_URL=https://test-api.example.com
 BASE_URL=https://example.com
 AUTH_URL=https://auth.example.com
 PAYMENT_URL=https://payment.example.com

package/.vscode/settings.json

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

package/cucumber.js

@@ -6,10 +6,10 @@ module.exports = {
       "json:./src/examples/reports/load-report.json",
       "html:./src/examples/reports/report.html",
     ],
-    paths: ["./src/examples/features/loadTestTemplate.feature"],
-    tags: process.env.TAGS,
+    paths: ["./src/examples/features/*.feature"],
+    tags: "@load",
     worldParameters: {
-      payloadPath: "apps/qa/performance/payloads",
+      payloadPath: "src/examples/payloads",
     },
     overwrite: true,
     reporter: true,

package/lib/helpers/buildK6Script.js

@@ -21,6 +21,10 @@ module.exports = function buildK6Script(config) {
     return url.startsWith("/") ? `${BASE_URL}${url}` : url;
   };
 
+  // Convert to inline JS object (not stringified) so K6 can call JSON.stringify() itself
+  const stringifiedHeaders = JSON.stringify(headers, null, 2);
+  const stringifiedBody = JSON.stringify(body, null, 2);
+
   return `
 import http from 'k6/http';
 import { check } from 'k6';
@@ -28,6 +32,9 @@ import { check } from 'k6';
 export const options = ${JSON.stringify(options, null, 2)};
 
 export default function () {
+  const headers = ${stringifiedHeaders};
+  const body = ${stringifiedBody};
+
   ${
     endpoints?.length
       ? endpoints
@@ -37,15 +44,13 @@ export default function () {
     const res${i} = http.request("${method}", resolvedUrl${i}, ${
               method === "GET" || method === "DELETE"
                 ? "null"
-                : JSON.stringify(body)
-            }, {
-      headers: ${JSON.stringify(headers, null, 2)}
-    });
+                : "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")
       : `
@@ -53,10 +58,8 @@ export default function () {
     const res = http.request("${method}", resolvedUrl, ${
           method === "GET" || method === "DELETE"
             ? "null"
-            : JSON.stringify(body)
-        }, {
-      headers: ${JSON.stringify(headers, null, 2)}
-    });
+            : "JSON.stringify(body)"
+        }, { headers });
     console.log(\`Response Body for \${resolvedUrl}: \${res.body}\`);
     check(res, {
       "status is 2xx": (r) => r.status >= 200 && r.status < 300

package/lib/helpers/generateHeaders.js

@@ -21,9 +21,9 @@ module.exports = function generateHeaders(authType, env, aliases = {}) {
     ).toString("base64");
     headers["Authorization"] = `Basic ${base64}`;
   } else if (authType === "none") {
-    // Do nothing extra
+    // No auth, just default content-type
   } else if (aliases[authType]) {
-    // Dynamic alias token support
+    // ✅ Custom alias support
     headers["Authorization"] = `Bearer ${getValue(authType)}`;
   } else {
     throw new Error(

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.39",
+  "version": "1.0.41",
   "main": "index.js",
   "license": "MIT",
   "repository": {

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 = {};
 
-    // Validate thresholds only if they are not placeholders
-    const validateIfNotPlaceholder = (value) => {
-      if (value && !/^<.*>$/.test(value)) {
-        validateThreshold(value);
+    // 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);
+
+    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 = {
@@ -198,8 +224,13 @@ When(
  * When I set the authentication type to "none"
  */
 When("I set the authentication type to {string}", function (authType) {
-  this.config.headers = generateHeaders(authType, process.env);
+  this.config.headers = generateHeaders(
+    authType,
+    process.env,
+    this.aliases || {}
+  );
 });
+
 /**
  * Then I store the value at "data.token" as alias "token"
  */

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];
+        }
+      });
+    }
   }
 }