k6-cucumber-steps 1.2.18 → 1.2.20

package/bin/k6-cucumber-steps.js

@@ -24,11 +24,9 @@ program
   .option("--overwrite", "Overwrite report files", false)
   .option("--cleanReports", "Clean the reports folder before running", false)
   .option("--reporter", "Enable report generation", false)
-  .option("--clean", "Alias for --cleanReports")
+  .option("--clean", "Alias for --cleanReports", false)
   .option("-p, --payloadPath <dir>", "Directory for payload files")
   // Add CLI options for all config options
-  .option("--script <file>", "k6 script file to run")
-  .option("--k6Config <file>", "k6 config file to use")
   .action(async (argv) => {
     // Load config file
     const configFileInput =

package/lib/helpers/buildK6Script.js

@@ -1,5 +1,6 @@
 module.exports = function buildK6Script(config) {
-  const { method, endpoints, endpoint, body, headers, options, baseUrl } = config;
+  const { method, endpoints, endpoint, body, headers, options, baseUrl } =
+    config;
 
   const BASE_URL =
     baseUrl ||
@@ -54,7 +55,8 @@ export default function () {
                 : "JSON.stringify(body)"
             }, { headers });
   check(res${i}, {
-    "status is 2xx": (r) => r.status >= 200 && r.status < 300
+    "status is 2xx": (r) => r.status >= 200 && r.status < 300,
+  "response body is not empty": (r) => r.body && r.body.length > 0,
   });
   `
           )
@@ -67,7 +69,8 @@ export default function () {
             : "JSON.stringify(body)"
         }, { headers });
   check(res, {
-    "status is 2xx": (r) => r.status >= 200 && r.status < 300
+    "status is 2xx": (r) => r.status >= 200 && r.status < 300,
+  "response body is not empty": (r) => r.body && r.body.length > 0,
   });
   `
   }

package/lib/helpers/resolveBody.js

@@ -1,62 +1,74 @@
-/**
- * @module resolveBody
- * @description
- * This module resolves placeholders in a template string using environment variables,
- * Faker templates, and JSON file includes.
- * It supports the following types of placeholders:
- * 1. Environment variables: {{username}} will be replaced with the value of process.env.username.
- * 2. Faker templates: {{faker.internet.email}} will be replaced with a randomly generated email address.
- * 3. JSON file includes: <address.json> will be replaced with the contents of the address.json file.
- * */
 const fs = require("fs");
 const path = require("path");
-const faker = require("@faker-js/faker");
-
-module.exports = function resolveBody(template, env) {
-  let result = template;
-  console.log("Resolving body template:", template);
-  console.log("Resolved body result:", result);
-  // Replace env vars like {{username}}
-  result = result.replace(/{{(\w+)}}/g, (_, key) => {
-    if (!(key in env)) {
-      console.warn(`Missing environment variable for placeholder: {{${key}}}`);
-    }
-    return env[key] || "";
-  });
-
-  // Support faker templates like {{faker.internet.email}}
-  result = result.replace(/{{faker\.([\w.]+)}}/g, (_, methodPath) => {
-    const parts = methodPath.split(".");
-    let fn = faker;
-    for (const part of parts) {
-      fn = fn?.[part]; // Use optional chaining to avoid errors
-      if (!fn) {
-        throw new Error(`Invalid Faker template: {{faker.${methodPath}}}`);
+const faker = require("@faker-js/faker").faker;
+
+/**
+ * Recursively resolves all placeholders in an object.
+ * @param {*} data - The parsed JSON (object, array, string, etc)
+ * @param {object} env - Environment variables + aliases
+ * @returns {*} - Fully resolved structure
+ */
+function resolveDeep(data, env) {
+  if (typeof data === "string") {
+    // 1. Resolve env vars like {{username}}
+    data = data.replace(/{{(\w+)}}/g, (_, key) => {
+      return env[key] || "";
+    });
+
+    // 2. Resolve faker like {{faker.internet.email}}
+    data = data.replace(/{{faker\.([\w.]+)}}/g, (_, methodPath) => {
+      const parts = methodPath.split(".");
+      let fn = faker;
+      for (const part of parts) {
+        fn = fn?.[part];
+        if (!fn) throw new Error(`Invalid Faker method: faker.${methodPath}`);
       }
+      return typeof fn === "function" ? fn() : fn;
+    });
+
+    // 3. Replace JSON file includes like <address.json>
+    data = data.replace(/<([\w-]+\.json)>/g, (_, fileName) => {
+      const filePath = path.join(__dirname, "../payloads", fileName);
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Payload file not found: ${fileName}`);
+      }
+      const fileContent = fs.readFileSync(filePath, "utf-8");
+      return fileContent.trim();
+    });
+
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    return data.map((item) => resolveDeep(item, env));
+  }
+
+  if (typeof data === "object" && data !== null) {
+    const resolved = {};
+    for (const key in data) {
+      resolved[key] = resolveDeep(data[key], env);
     }
-    if (typeof fn !== "function") {
-      throw new Error(`Invalid Faker template: {{faker.${methodPath}}}`);
-    }
-    return fn();
-  });
-
-  // Replace JSON file includes like <address.json>
-  result = result.replace(/<([\w.]+\.json)>/g, (_, fileName) => {
-    const filePath = path.join(__dirname, "../payloads", fileName);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Payload file not found: ${fileName}`);
-    }
-    try {
-      return JSON.stringify(JSON.parse(fs.readFileSync(filePath, "utf-8")));
-    } catch (error) {
-      throw new Error(`Failed to parse JSON file: ${fileName}`);
-    }
-  });
+    return resolved;
+  }
 
+  return data;
+}
+
+/**
+ * Resolves JSON templates using env vars, Faker, and JSON includes.
+ * @param {string} template - The raw JSON string template
+ * @param {object} env - Object containing environment variables or aliases
+ * @returns {object} - Fully resolved JS object
+ */
+module.exports = function resolveBody(template, env = {}) {
   try {
-    return JSON.parse(result);
-  } catch (error) {
-    console.error("Failed to parse resolved body to JSON:", result);
-    throw new Error("Invalid JSON body after resolving placeholders.");
+    const parsed = JSON.parse(template);
+    return resolveDeep(parsed, env);
+  } catch (err) {
+    console.error(
+      "❌ Failed to parse input JSON before resolving:",
+      err.message
+    );
+    throw new Error("Invalid JSON template provided to resolveBody");
   }
 };

package/lib/helpers/runK6ScriptFromWorld.js

@@ -0,0 +1,36 @@
+const { generateK6Script, runK6Script } = require("./runner");
+const buildK6Script = require("./buildK6Script");
+
+/**
+ * Runs a K6 script using values from the World instance.
+ * Supports both single and multiple endpoints.
+ *
+ * @param {object} world - Cucumber World instance
+ * @param {string} method - HTTP method
+ * @param {boolean} isMulti - Flag to use `world.endpoints` instead of `endpoint`
+ */
+async function runK6ScriptFromWorld(world, method, isMulti = false) {
+  const scriptContent = buildK6Script({
+    method,
+    endpoint: isMulti ? undefined : world.endpoint,
+    endpoints: isMulti ? world.endpoints : undefined,
+    body: world.body,
+    headers: world.headers,
+    options: world.k6Options,
+    baseUrl: world.baseUrl,
+    worldParameters: world.worldParameters,
+  });
+
+  const scriptPath = await generateK6Script(scriptContent, "api", true);
+  const { stdout, stderr, code } = await runK6Script(scriptPath, true);
+
+  console.log(stdout);
+  if (stderr) console.error(stderr);
+  if (code !== 0) {
+    throw new Error("❌ K6 script execution failed.");
+  }
+
+  console.log("✅ K6 script ran successfully.");
+}
+
+module.exports = runK6ScriptFromWorld;

package/package.json

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

package/step_definitions/load_test_steps.js

@@ -7,9 +7,10 @@ import crypto from "crypto";
 import * as dotenv from "dotenv";
 import resolvePayloadPath from "../lib/helpers/resolvePayloadPath.js";
 import resolveBody from "../lib/helpers/resolveBody.js";
-import buildK6Script from "../lib/helpers/buildK6Script.js";
+// import buildK6Script from "../lib/helpers/buildK6Script.js";
 import generateHeaders from "../lib/helpers/generateHeaders.js";
-import { runK6Script } from "../lib/utils/k6Runner.js";
+// import { runK6Script } from "../lib/utils/k6Runner.js";
+const runK6ScriptFromWorld = require("../../../helpers/runK6ScriptFromWorld");
 
 dotenv.config();
 
@@ -608,79 +609,95 @@ if (!fs.existsSync(reportDir)) {
   fs.mkdirSync(reportDir, { recursive: true });
 }
 
+// Then(
+//   /^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.");
+//     }
+//     const expectedMethod = method.toUpperCase();
+//     const actualMethod = this.config.method.toUpperCase();
+//     if (actualMethod !== expectedMethod) {
+//       throw new Error(
+//         `Mismatched HTTP method: expected "${expectedMethod}", got "${actualMethod}"`
+//       );
+//     }
+//     try {
+//       const scriptContent = buildK6Script(this.config);
+//       const uniqueId = crypto.randomBytes(8).toString("hex");
+//       const scriptFileName = `k6-script-${uniqueId}.js`;
+//       const scriptPath = path.join(reportDir, scriptFileName);
+//       fs.writeFileSync(scriptPath, scriptContent, "utf-8");
+//       this.log?.(`✅ k6 script generated at: "${scriptPath}"`);
+
+//       this.log?.(`🚀 Running k6 script: "${scriptFileName}"...`);
+//       const { stdout, stderr, code } = await runK6Script(
+//         scriptPath,
+//         process.env.K6_CUCUMBER_OVERWRITE === "true"
+//       );
+//       if (stdout) this.log?.(`k6 STDOUT:\n${stdout}`);
+//       if (stderr) this.log?.(`k6 STDERR:\n${stderr}`);
+
+//       if (code !== 0) {
+//         throw new Error(
+//           `k6 process exited with code ${code}. Check k6 output for details.`
+//         );
+//       }
+//       this.log?.(
+//         `✅ k6 script executed successfully for ${expectedMethod} request.`
+//       );
+
+//       const saveK6Script =
+//         process.env.saveK6Script === "true" ||
+//         process.env.SAVE_K6_SCRIPT === "true" ||
+//         this.parameters?.saveK6Script === true;
+
+//       if (!saveK6Script) {
+//         try {
+//           fs.unlinkSync(scriptPath);
+//           this.log?.(`🧹 Temporary k6 script deleted: "${scriptPath}"`);
+//         } catch (cleanupErr) {
+//           this.log?.(
+//             `⚠️ Warning: Could not delete temporary k6 script file: "${scriptPath}". Error: ${
+//               cleanupErr instanceof Error
+//                 ? cleanupErr.message
+//                 : String(cleanupErr)
+//             }`
+//           );
+//         }
+//       } else {
+//         this.log?.(
+//           `ℹ️  k6 script kept at: "${scriptPath}". Set SAVE_K6_SCRIPT=false to delete automatically.`
+//         );
+//       }
+//     } catch (error) {
+//       this.log?.(
+//         `❌ Failed to generate or run k6 script: ${
+//           error instanceof Error ? error.message : String(error)
+//         }`
+//       );
+//       throw new Error(
+//         `k6 script generation or execution failed: ${
+//           error instanceof Error ? error.message : String(error)
+//         }`
+//       );
+//     }
+//   }
+// );
+
+// Single endpoint
 Then(
-  /^I see the API should handle the (\w+) request successfully$/,
-  { timeout: 300000 },
+  "I see the API should handle the {word} request successfully",
   async function (method) {
-    if (!this.config || !this.config.method) {
-      throw new Error("Configuration is missing or incomplete.");
-    }
-    const expectedMethod = method.toUpperCase();
-    const actualMethod = this.config.method.toUpperCase();
-    if (actualMethod !== expectedMethod) {
-      throw new Error(
-        `Mismatched HTTP method: expected "${expectedMethod}", got "${actualMethod}"`
-      );
-    }
-    try {
-      const scriptContent = buildK6Script(this.config);
-      const uniqueId = crypto.randomBytes(8).toString("hex");
-      const scriptFileName = `k6-script-${uniqueId}.js`;
-      const scriptPath = path.join(reportDir, scriptFileName);
-      fs.writeFileSync(scriptPath, scriptContent, "utf-8");
-      this.log?.(`✅ k6 script generated at: "${scriptPath}"`);
-
-      this.log?.(`🚀 Running k6 script: "${scriptFileName}"...`);
-      const { stdout, stderr, code } = await runK6Script(
-        scriptPath,
-        process.env.K6_CUCUMBER_OVERWRITE === "true"
-      );
-      if (stdout) this.log?.(`k6 STDOUT:\n${stdout}`);
-      if (stderr) this.log?.(`k6 STDERR:\n${stderr}`);
-
-      if (code !== 0) {
-        throw new Error(
-          `k6 process exited with code ${code}. Check k6 output for details.`
-        );
-      }
-      this.log?.(
-        `✅ k6 script executed successfully for ${expectedMethod} request.`
-      );
+    await runK6ScriptFromWorld(this, method);
+  }
+);
 
-      const saveK6Script =
-        process.env.saveK6Script === "true" ||
-        process.env.SAVE_K6_SCRIPT === "true" ||
-        this.parameters?.saveK6Script === true;
-
-      if (!saveK6Script) {
-        try {
-          fs.unlinkSync(scriptPath);
-          this.log?.(`🧹 Temporary k6 script deleted: "${scriptPath}"`);
-        } catch (cleanupErr) {
-          this.log?.(
-            `⚠️ Warning: Could not delete temporary k6 script file: "${scriptPath}". Error: ${
-              cleanupErr instanceof Error
-                ? cleanupErr.message
-                : String(cleanupErr)
-            }`
-          );
-        }
-      } else {
-        this.log?.(
-          `ℹ️  k6 script kept at: "${scriptPath}". Set SAVE_K6_SCRIPT=false to delete automatically.`
-        );
-      }
-    } catch (error) {
-      this.log?.(
-        `❌ Failed to generate or run k6 script: ${
-          error instanceof Error ? error.message : String(error)
-        }`
-      );
-      throw new Error(
-        `k6 script generation or execution failed: ${
-          error instanceof Error ? error.message : String(error)
-        }`
-      );
-    }
+// Multi-endpoint
+Then(
+  "I run the script for multiple endpoints with method {word}",
+  async function (method) {
+    await runK6ScriptFromWorld(this, method, true);
   }
 );