k6-cucumber-steps 1.1.13 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k6-cucumber-steps",
-  "version": "1.1.13",
+  "version": "1.2.1",
   "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,354 +3,406 @@
 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");
 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).
+ * Sets the HTTP method for the k6 script.
+ *
+ * ```gherkin
+ * Given I set a k6 script for {word} testing
+ * ```
  * @example
  * Given I set a k6 script for GET testing
- * Given I set a k6 script for POST testing
+ * @category K6 Steps
  */
-Given("I set a k6 script for {word} testing", function (method) {
+async function Given_I_set_a_k6_script_for_method(this, method) {
   this.config = { method: method.toUpperCase() };
-});
+}
+Given(/^I set a k6 script for (\w+) testing$/, Given_I_set_a_k6_script_for_method);
 
 /**
- * @param {DataTable} dataTable - Table with configurations.
+ * Sets k6 script options from a configuration table.
+ *
+ * ```gherkin
+ * When I set to run the k6 script with the following configurations:
+ *   | virtual_users | duration | http_req_failed | http_req_duration | error_rate | stages |
+ * ```
  * @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"}] |
+ *   | virtual_users | duration | http_req_failed | http_req_duration | error_rate | stages |
+ *   | 10            | 5        | rate<0.05       | p(95)<200         |            |        |
+ * @category K6 Steps
  */
-When(
-  "I set to run the k6 script with the following configurations:",
-  function (dataTable) {
-    const rawRow = dataTable.hashes()[0];
-    const row = {};
-
-    // 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];
-      });
-    }
+async function When_I_set_k6_script_configurations(this, dataTable) {
+  const rawRow = dataTable.hashes()[0];
+  const row = {};
+
+  // 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;
+    });
 
-    for (const [key, value] of Object.entries(rawRow)) {
-      row[key] = value.replace(/<([^>]+)>/g, (_, param) => {
-        return exampleMap[param] || value;
-      });
-    }
+    const exampleValues =
+      scenario?.scenario?.examples?.[0]?.tableBody?.[0]?.cells?.map(
+        (cell) => cell.value
+      ) || [];
 
-    console.log("🚨 Resolved config row:", row);
+    const exampleKeys =
+      scenario?.scenario?.examples?.[0]?.tableHeader?.cells?.map(
+        (cell) => cell.value
+      ) || [];
 
-    const validateThreshold = (value) => {
-      const regex = /^[\w{}()<>:]+[<>=]\d+(\.\d+)?$/;
-      if (value && !regex.test(value)) {
-        throw new Error(`Invalid threshold format: ${value}`);
-      }
-    };
+    exampleKeys.forEach((key, idx) => {
+      exampleMap[key] = exampleValues[idx];
+    });
+  }
 
-    validateThreshold(row.http_req_failed);
-    validateThreshold(row.http_req_duration);
-    validateThreshold(row.error_rate);
-
-    if (row.stages) {
-      try {
-        this.config.options = {
-          stages: JSON.parse(row.stages),
-          thresholds: {
-            http_req_failed: [row.http_req_failed],
-            http_req_duration: [row.http_req_duration],
-          },
-        };
-      } catch {
-        throw new Error("Invalid stages JSON format.");
-      }
-    } else {
+  for (const [key, value] of Object.entries(rawRow)) {
+    row[key] = value.replace(/<([^>]+)>/g, (_, param) => {
+      return exampleMap[param] || value;
+    });
+  }
+
+  const validateThreshold = (value) => {
+    const regex = /^[\w{}()<>:]+[<>=]\d+(\.\d+)?$/;
+    if (value && !regex.test(value)) {
+      throw new Error(`Invalid threshold format: ${value}`);
+    }
+  };
+
+  validateThreshold(row.http_req_failed);
+  validateThreshold(row.http_req_duration);
+  validateThreshold(row.error_rate);
+
+  if (row.stages) {
+    try {
       this.config.options = {
-        vus: parseInt(row.virtual_users),
-        duration: `${row.duration}s`,
+        stages: JSON.parse(row.stages),
         thresholds: {
           http_req_failed: [row.http_req_failed],
           http_req_duration: [row.http_req_duration],
         },
       };
+    } catch {
+      throw new Error("Invalid stages JSON format.");
     }
+  } else {
+    this.config.options = {
+      vus: parseInt(row.virtual_users),
+      duration: `${row.duration}s`,
+      thresholds: {
+        http_req_failed: [row.http_req_failed],
+        http_req_duration: [row.http_req_duration],
+      },
+    };
+  }
 
-    if (row.error_rate) {
-      this.config.options.thresholds.error_rate = [row.error_rate];
-    }
+  if (row.error_rate) {
+    this.config.options.thresholds.error_rate = [row.error_rate];
   }
+}
+When(
+  /^I set to run the k6 script with the following configurations:$/,
+  When_I_set_k6_script_configurations
 );
 
 /**
- * @param {DataTable} dataTable - Table with header and value for request headers.
+ * Sets request headers for the k6 script.
+ *
+ * ```gherkin
+ * When I set the request headers:
+ *   | Header        | Value                  |
+ * ```
  * @example
  * When I set the request headers:
- * | Header        | Value                     |
- * | Content-Type  | application/json          |
- * | Authorization | Bearer your_auth_token    |
+ *   | Header        | Value                  |
+ *   | Content-Type  | application/json       |
+ * @category K6 Steps
  */
-When("I set the request headers:", function (dataTable) {
+async function When_I_set_request_headers(this, 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,
   };
-});
+}
+When(/^I set the request headers:$/, When_I_set_request_headers);
 
 /**
- * @param {string} docString - Multiline string containing the endpoints.
+ * Sets endpoints for the k6 script.
+ *
+ * ```gherkin
+ * When I set the following endpoints used:
+ * """
+ * /api/users
+ * /api/products
+ * """
+ * ```
  * @example
  * When I set the following endpoints used:
  * """
  * /api/users
  * /api/products
  * """
+ * @category K6 Steps
  */
-When("I set the following endpoints used:", function (docString) {
+async function When_I_set_endpoints_used(this, docString) {
   this.config.endpoints = docString
     .trim()
     .split("\n")
     .map((line) => line.trim());
-});
+}
+When(/^I set the following endpoints used:$/, When_I_set_endpoints_used);
 
 /**
- * @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).
+ * Sets the request body for a specific method and endpoint.
+ *
+ * ```gherkin
+ * When I set the following {word} body is used for {string}
+ * """
+ * { ... }
+ * """
+ * ```
  * @example
  * When I set the following POST body is used for "/api/users"
  * """
- * {
- * "username": "{{username}}",
- * "email": "{{faker.internet.email}}"
- * }
+ * { "username": "{{username}}" }
  * """
+ * @category K6 Steps
  */
+async function When_I_set_body_for_method_and_endpoint(this, method, endpoint, docString) {
+  this.config.method = method.toUpperCase();
+  this.config.body = resolveBody(docString, process.env);
+  this.config.endpoint = endpoint;
+}
 When(
-  "I set the following {word} body is used for {string}",
-  function (method, endpoint, docString) {
-    this.config.method = method.toUpperCase();
-    this.config.body = resolveBody(docString, process.env);
-    this.config.endpoint = endpoint;
-  }
+  /^I set the following (\w+) body is used for "([^"]+)"$/,
+  When_I_set_body_for_method_and_endpoint
 );
 
-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(
-          ", "
-        )}`
-      );
-    }
+/**
+ * Loads a JSON payload for a method and endpoint.
+ *
+ * ```gherkin
+ * When I use JSON payload from {string} for {word} to {string}
+ * ```
+ * @example
+ * When I use JSON payload from "login.json" for POST to "/api/login"
+ * @category K6 Steps
+ */
+async function When_I_use_JSON_payload(this, 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 projectRoot = path.resolve(__dirname, "..", "..");
-    const payloadDir = this.parameters?.payloadPath || "payloads";
-    const payloadPath = path.isAbsolute(payloadDir)
-      ? path.join(payloadDir, fileName)
-      : path.join(__dirname, "..", "..", payloadDir, fileName);
+  const projectRoot = path.resolve(__dirname, "..", "..");
+  const payloadDir = this.parameters?.payloadPath || "payloads";
+  const payloadPath = path.isAbsolute(payloadDir)
+    ? path.join(payloadDir, fileName)
+    : path.join(projectRoot, payloadDir, fileName);
 
-    if (!fs.existsSync(payloadPath)) {
-      throw new Error(`Payload file not found: ${payloadPath}`);
-    }
+  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 || {}),
-    });
+  const rawTemplate = fs.readFileSync(payloadPath, "utf-8");
+  const resolved = resolveBody(rawTemplate, {
+    ...process.env,
+    ...(this.aliases || {}),
+  });
 
-    this.config = {
-      ...this.config, // ✅ Keep previously set options!
-      method: methodUpper,
-      endpoint,
-      body: resolved,
-      headers: this.config?.headers || {},
-    };
+  this.config = {
+    ...this.config,
+    method: methodUpper,
+    endpoint,
+    body: resolved,
+    headers: this.config?.headers || {},
+  };
 
-    this.lastRequest = {
-      method: methodUpper,
-      endpoint,
-      body: resolved,
-    };
-  }
+  this.lastRequest = {
+    method: methodUpper,
+    endpoint,
+    body: resolved,
+  };
+}
+When(
+  /^I use JSON payload from "([^"]+)" for (\w+) to "([^"]+)"$/,
+  When_I_use_JSON_payload
 );
 
 /**
- * @param {string} authType - Authentication type (api_key, bearer_token, basic, none).
+ * Sets the authentication type for the request.
+ *
+ * ```gherkin
+ * When I set the authentication type to {string}
+ * ```
  * @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"
+ * @category K6 Steps
  */
-When("I set the authentication type to {string}", function (authType) {
+async function When_I_set_authentication_type(this, authType) {
   this.config.headers = generateHeaders(
     authType,
     process.env,
     this.aliases || {}
   );
-});
+}
+When(/^I set the authentication type to "([^"]+)"$/, When_I_set_authentication_type);
 
 /**
+ * Stores a value from the last response as an alias.
+ *
+ * ```gherkin
+ * Then I store the value at {string} as alias {string}
+ * ```
+ * @example
  * Then I store the value at "data.token" as alias "token"
+ * @category K6 Steps
  */
-Then(
-  "I store the value at {string} as alias {string}",
-  function (jsonPath, alias) {
-    if (!this.lastResponse) {
-      throw new Error("No previous response available.");
-    }
+async function Then_I_store_value_as_alias(this, jsonPath, alias) {
+  if (!this.lastResponse) {
+    throw new Error("No previous response available.");
+  }
 
-    const pathParts = jsonPath.split(".");
-    let value = this.lastResponse;
+  const pathParts = jsonPath.split(".");
+  let value = this.lastResponse;
 
-    for (const key of pathParts) {
-      value = value?.[key];
-      if (value === undefined) break;
-    }
+  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 (value === undefined) {
+    throw new Error(`Could not resolve path "${jsonPath}" in the response`);
+  }
 
-    if (!this.aliases) this.aliases = {};
-    this.aliases[alias] = value;
+  if (!this.aliases) this.aliases = {};
+  this.aliases[alias] = value;
 
-    console.log(`🧩 Stored alias "${alias}":`, value);
-  }
+  console.log(`🧩 Stored alias "${alias}":`, value);
+}
+Then(
+  /^I store the value at "([^"]+)" as alias "([^"]+)"$/,
+  Then_I_store_value_as_alias
 );
-When(
-  "I login via POST to {string} with payload from {string}",
-  async function (endpoint, fileName) {
-    const payloadDir = this.parameters?.payloadPath || "payloads";
-    const payloadPath = path.isAbsolute(payloadDir)
-      ? path.join(payloadDir, fileName)
-      : path.join(__dirname, "..", "..", 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 || {}),
-    });
+/**
+ * Logs in via POST to an endpoint with a payload from a file.
+ *
+ * ```gherkin
+ * When I login via POST to {string} with payload from {string}
+ * ```
+ * @example
+ * When I login via POST to "/api/login" with payload from "login.json"
+ * @category K6 Steps
+ */
+async function When_I_login_via_POST_with_payload(this, endpoint, fileName) {
+  const payloadDir = this.parameters?.payloadPath || "payloads";
+  const projectRoot = path.resolve(__dirname, "..", "..");
+  const payloadPath = path.isAbsolute(payloadDir)
+    ? path.join(payloadDir, fileName)
+    : path.join(projectRoot, payloadDir, fileName);
+
+  if (!fs.existsSync(payloadPath)) {
+    throw new Error(`Payload file not found: ${payloadPath}`);
+  }
 
-    try {
-      const response = await fetch(`${process.env.BASE_URL}${endpoint}`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(resolved),
-      });
+  const rawTemplate = fs.readFileSync(payloadPath, "utf-8");
+  const resolved = resolveBody(rawTemplate, {
+    ...process.env,
+    ...(this.aliases || {}),
+  });
 
-      const data = await response.json();
+  try {
+    const response = await fetch(`${process.env.BASE_URL}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(resolved),
+    });
 
-      if (!response.ok) {
-        console.error("❌ Login request failed:", data);
-        throw new Error(`Login request failed with status ${response.status}`);
-      }
+    const data = await response.json();
 
-      this.lastResponse = 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");
+    if (!response.ok) {
+      console.error("❌ Login request failed:", data);
+      throw new Error(`Login request failed with status ${response.status}`);
     }
+
+    this.lastResponse = data;
+    console.log("🔐 Login successful, response saved to alias context.");
+  } catch (err) {
+    console.error("❌ Login request failed:", err.message);
+    throw new Error("Login request failed");
   }
+}
+When(
+  /^I login via POST to "([^"]+)" with payload from "([^"]+)"$/,
+  When_I_login_via_POST_with_payload
 );
 
 /**
- * @param {string} method - HTTP method of the request.
+ * Executes the k6 script and checks the result.
+ *
+ * ```gherkin
+ * Then I see the API should handle the {word} request successfully
+ * ```
  * @example
- * Then I see the API should handle the GET request successfully
  * Then I see the API should handle the POST request successfully
+ * @category K6 Steps
  */
-Then(
-  "I see the API should handle the {word} request successfully",
-  { timeout: 60000 },
-  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 {
-      // Build the k6 script content
-      const scriptContent = buildK6Script(this.config);
-
-      // Generate the k6 script file
-      const scriptPath = await generateK6Script(
-        scriptContent,
-        "load",
-        process.env.K6_CUCUMBER_OVERWRITE === "true"
-      );
-
-      // Run the k6 script and capture output
-      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}`);
-      }
-    } catch (error) {
-      // Print the full error for debugging
-      console.error("k6 execution failed:", error.stack || error);
-      throw new Error("k6 test execution failed");
+async function Then_I_see_API_should_handle_request(this, 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 scriptPath = await generateK6Script(
+      scriptContent,
+      "load",
+      process.env.K6_CUCUMBER_OVERWRITE === "true"
+    );
+    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}`);
     }
+  } catch (error) {
+    console.error("k6 execution failed:", error.stack || error);
+    throw new Error("k6 test execution failed");
   }
+}
+Then(
+  /^I see the API should handle the (\w+) request successfully$/,
+  Then_I_see_API_should_handle_request
 );