k6-cucumber-steps 1.0.34 → 1.0.36

package/README.md

@@ -217,16 +217,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/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.34",
+  "version": "1.0.36",
   "main": "index.js",
   "license": "MIT",
   "repository": {
@@ -53,18 +53,20 @@
     "@babel/cli": "latest",
     "@babel/core": "latest",
     "@babel/preset-env": "latest",
-    "@babel/register": "latest",
-    "@cucumber/cucumber": "latest",
-    "@faker-js/faker": "latest",
     "@types/k6": "latest",
     "child_process": "latest",
     "cucumber-console-formatter": "latest",
     "cucumber-html-reporter": "latest",
-    "dotenv": "latest",
     "esbuild": "latest",
     "form-data": "latest",
     "k6": "latest",
-    "tsconfig-paths": "latest",
+    "tsconfig-paths": "latest"
+  },
+  "dependencies": {
+    "@babel/register": "latest",
+    "@cucumber/cucumber": "latest",
+    "@faker-js/faker": "latest",
+    "dotenv": "latest",
     "yargs": "latest"
   }
 }

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.