k6-cucumber-steps 1.0.35 → 1.0.37

package/README.md

@@ -150,6 +150,7 @@ npx k6-cucumber-steps run --configFile cucumber.prod.js
 
     ```env
     BASE_URL=[https://api.example.com](https://api.example.com)
+    API_BASE_URL=[https://api.example.com](https://api.example.com)
     API_KEY=your_api_key
     BEARER_TOKEN=your_bearer_token
     BASIC_USER=your_basic_user
@@ -217,16 +218,20 @@ When I set the authentication type to "api_key"
 When I set the authentication type to "bearer_token"
 When I set the authentication type to "basic"
 When I set the authentication type to "none"
+When I set the authentication type to "custom-alias"
 ```
 
 ### Request Configuration Steps
 
 ```gherkin
 Given I set a k6 script for {word} testing
+Given I login via POST to {string} with payload from {string}
 When I set to run the k6 script with the following configurations:
 When I set the request headers:
 When I set the following endpoints used:
 When I set the following {word} body is used for {string}
+When I store the value at {string} as alias {string}
+
 ```
 
 ### Assertion Steps

package/lib/helpers/buildK6Script.js

@@ -1,5 +1,6 @@
 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(
@@ -7,10 +8,12 @@ module.exports = function buildK6Script(config) {
     );
   }
 
-  // Get BASE_URL from environment variables
-  const BASE_URL = process.env.BASE_URL;
+  // 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("BASE_URL is not defined in the environment variables.");
+    throw new Error(
+      "Neither API_BASE_URL nor BASE_URL is defined in the environment variables."
+    );
   }
 
   // Resolve relative endpoints by prepending BASE_URL
@@ -47,7 +50,7 @@ export default function () {
           .join("\n")
       : `
     const resolvedUrl = "${resolveEndpoint(endpoint)}";
-\    const res = http.request("${method}", resolvedUrl, ${
+    const res = http.request("${method}", resolvedUrl, ${
           method === "GET" || method === "DELETE"
             ? "null"
             : JSON.stringify(body)

package/lib/helpers/generateHeaders.js

@@ -6,23 +6,29 @@
  * Generates HTTP headers based on the specified authentication type.
  * Supported auth types: api_key, bearer_token, basic, none.
  */
-module.exports = function generateHeaders(authType, env) {
+module.exports = function generateHeaders(authType, env, aliases = {}) {
   const headers = { "Content-Type": "application/json" };
 
+  const getValue = (key) => env[key] || aliases[key] || "";
+
   if (authType === "api_key") {
-    headers["x-api-key"] = env.API_KEY || "";
+    headers["x-api-key"] = getValue("API_KEY");
   } else if (authType === "bearer_token") {
-    headers["Authorization"] = `Bearer ${env.BEARER_TOKEN || ""}`;
+    headers["Authorization"] = `Bearer ${getValue("token")}`;
   } else if (authType === "basic") {
-    const base64 = Buffer.from(`${env.BASIC_USER}:${env.BASIC_PASS}`).toString(
-      "base64"
-    );
+    const base64 = Buffer.from(
+      `${getValue("BASIC_USER")}:${getValue("BASIC_PASS")}`
+    ).toString("base64");
     headers["Authorization"] = `Basic ${base64}`;
   } else if (authType === "none") {
-    // No additional headers for "no auth"
-    // Default headers (e.g., Content-Type) are still included
+    // Do nothing extra
+  } else if (aliases[authType]) {
+    // Dynamic alias token support
+    headers["Authorization"] = `Bearer ${getValue(authType)}`;
   } else {
-    throw new Error(`Unsupported authentication type: ${authType}`);
+    throw new Error(
+      `Unsupported authentication type or missing alias: ${authType}`
+    );
   }
 
   return headers;

package/package.json

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

package/step_definitions/load_test_steps.js

@@ -9,6 +9,7 @@ const buildK6Script = require("../lib/helpers/buildK6Script.js");
 const generateHeaders = require("../lib/helpers/generateHeaders.js");
 const { generateK6Script, runK6Script } = require("../lib/utils/k6Runner.js");
 require("dotenv").config();
+const axios = require("axios");
 
 // Validate thresholds (e.g., "rate<0.01")
 const validateThreshold = (threshold) => {
@@ -141,6 +142,49 @@ When(
   }
 );
 
+When(
+  "I use JSON payload from {string} for {word} to {string}",
+  function (fileName, method, endpoint) {
+    const allowedMethods = ["POST", "PUT", "PATCH"];
+    const methodUpper = method.toUpperCase();
+
+    if (!allowedMethods.includes(methodUpper)) {
+      throw new Error(
+        `Method "${method}" is not supported. Use one of: ${allowedMethods.join(
+          ", "
+        )}`
+      );
+    }
+
+    const payloadPath = path.resolve(__dirname, "../../payloads", fileName);
+    if (!fs.existsSync(payloadPath)) {
+      throw new Error(`Payload file not found: ${fileName}`);
+    }
+
+    const rawTemplate = fs.readFileSync(payloadPath, "utf-8");
+    const resolved = resolveBody(rawTemplate, {
+      ...process.env,
+      ...(this.aliases || {}),
+    });
+
+    this.config = {
+      method: methodUpper,
+      endpoint,
+      body: resolved,
+      headers: this.config?.headers || {},
+      options: {
+        vus: 1,
+        iterations: 1,
+      },
+    };
+
+    this.lastRequest = {
+      method: methodUpper,
+      endpoint,
+      body: resolved,
+    };
+  }
+);
 /**
  * @param {string} authType - Authentication type (api_key, bearer_token, basic, none).
  * @example
@@ -152,6 +196,69 @@ When(
 When("I set the authentication type to {string}", function (authType) {
   this.config.headers = generateHeaders(authType, process.env);
 });
+/**
+ * Then I store the value at "data.token" as alias "token"
+ */
+Then(
+  "I store the value at {string} as alias {string}",
+  function (jsonPath, alias) {
+    if (!this.lastResponse) {
+      throw new Error("No previous response available.");
+    }
+
+    const pathParts = jsonPath.split(".");
+    let value = this.lastResponse;
+
+    for (const key of pathParts) {
+      value = value?.[key];
+      if (value === undefined) break;
+    }
+
+    if (value === undefined) {
+      throw new Error(`Could not resolve path "${jsonPath}" in the response`);
+    }
+
+    if (!this.aliases) this.aliases = {};
+    this.aliases[alias] = value;
+
+    console.log(`🧩 Stored alias "${alias}":`, value);
+  }
+);
+When(
+  "I login via POST to {string} with payload from {string}",
+  async function (endpoint, fileName) {
+    const payloadPath = path.resolve(__dirname, "../../payloads", fileName);
+
+    if (!fs.existsSync(payloadPath)) {
+      throw new Error(`Payload file not found: ${fileName}`);
+    }
+
+    const rawTemplate = fs.readFileSync(payloadPath, "utf-8");
+
+    const resolved = resolveBody(rawTemplate, {
+      ...process.env,
+      ...(this.aliases || {}),
+    });
+
+    try {
+      const response = await axios.post(
+        `${process.env.BASE_URL}${endpoint}`,
+        resolved,
+        {
+          headers: {
+            "Content-Type": "application/json",
+          },
+        }
+      );
+
+      this.lastResponse = response.data; // ✅ Makes aliasing work
+      console.log("🔐 Login successful, response saved to alias context.");
+    } catch (err) {
+      console.error("❌ Login request failed:", err.message);
+      throw new Error("Login request failed");
+    }
+  }
+);
 
 /**
  * @param {string} method - HTTP method of the request.