k6-cucumber-steps 1.2.1 → 1.2.2

package/lib/helpers/buildK6Script.js

@@ -1,7 +1,6 @@
 module.exports = function buildK6Script(config) {
   const { method, endpoints, endpoint, body, headers, options, baseUrl } = config;
 
-  // Prefer baseUrl from config (set by step/world), then env
   const BASE_URL =
     baseUrl ||
     (config.worldParameters && config.worldParameters.baseUrl) ||
@@ -18,15 +17,19 @@ module.exports = function buildK6Script(config) {
     return url.startsWith("/") ? `${BASE_URL}${url}` : url;
   };
 
-  // Default headers/body/options for safety
   const safeHeaders = headers && Object.keys(headers).length ? headers : {};
   const safeBody = body !== undefined ? body : null;
   const safeOptions = options && Object.keys(options).length ? options : {};
 
-  // Stringify for script
   const stringifiedHeaders = JSON.stringify(safeHeaders, null, 2);
   const stringifiedBody = JSON.stringify(safeBody, null, 2);
 
+  const reportDir =
+    process.env.REPORT_OUTPUT_DIR ||
+    process.env.K6_REPORT_DIR ||
+    process.env.npm_config_report_output_dir ||
+    "reports";
+
   return `
 import http from 'k6/http';
 import { check } from 'k6';
@@ -50,7 +53,6 @@ export default function () {
                 ? "null"
                 : "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
   });
@@ -64,7 +66,6 @@ export default function () {
             ? "null"
             : "JSON.stringify(body)"
         }, { headers });
-  console.log(\`Response Body for \${resolvedUrl}: \${res.body}\`);
   check(res, {
     "status is 2xx": (r) => r.status >= 200 && r.status < 300
   });
@@ -73,24 +74,8 @@ export default function () {
 }
 
 export function handleSummary(data) {
-  const outputDir = __ENV.REPORT_OUTPUT_DIR || "reports";
-  const html = htmlReport(data);
-  const cucumberReportFile = "cucumber-report.html";
-  const cucumberLink = \`
-    <div style="text-align:center; margin-top:20px;">
-      <a href="\${cucumberReportFile}" style="font-size:18px; color:#0066cc;">
-        🔗 View Cucumber Test Report
-      </a>
-    </div>
-  \`;
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const k6ReportFilename = \`\${outputDir}/k6-report-\${timestamp}.html\`;
-
-  console.log(\`📄 K6 HTML report \${k6ReportFilename} generated successfully 👍\`);
-
   return {
-    [k6ReportFilename]: html.replace("</body>", \`\${cucumberLink}</body>\`),
+    "${reportDir}/k6-report.html": htmlReport(data),
     stdout: textSummary(data, { indent: " ", enableColors: true }),
   };
 }

package/package.json

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

package/step_definitions/load_test_steps.js

@@ -7,125 +7,98 @@ 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");
+const os = require("os");
+const crypto = require("crypto");
 require("dotenv").config();
 
 /**
  * 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
- * @category K6 Steps
  */
-async function Given_I_set_a_k6_script_for_method(this, method) {
+Given(/^I set a k6 script for (\w+) testing$/, async function (method) {
   this.config = { method: method.toUpperCase() };
-}
-Given(/^I set a k6 script for (\w+) testing$/, Given_I_set_a_k6_script_for_method);
+});
 
 /**
  * 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         |            |        |
- * @category K6 Steps
  */
-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;
-    });
-
-    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;
-    });
-  }
+When(
+  /^I set to run the k6 script with the following configurations:$/,
+  async 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];
+      });
+    }
 
-  const validateThreshold = (value) => {
-    const regex = /^[\w{}()<>:]+[<>=]\d+(\.\d+)?$/;
-    if (value && !regex.test(value)) {
-      throw new Error(`Invalid threshold format: ${value}`);
+    for (const [key, value] of Object.entries(rawRow)) {
+      row[key] = value.replace(/<([^>]+)>/g, (_, param) => {
+        return exampleMap[param] || value;
+      });
     }
-  };
 
-  validateThreshold(row.http_req_failed);
-  validateThreshold(row.http_req_duration);
-  validateThreshold(row.error_rate);
+    const validateThreshold = (value) => {
+      const regex = /^[\w{}()<>:]+[<>=]\d+(\.\d+)?$/;
+      if (value && !regex.test(value)) {
+        throw new Error(`Invalid threshold format: ${value}`);
+      }
+    };
 
-  if (row.stages) {
-    try {
+    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 {
       this.config.options = {
-        stages: JSON.parse(row.stages),
+        vus: parseInt(row.virtual_users),
+        duration: `${row.duration}s`,
         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
 );
 
 /**
  * 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       |
- * @category K6 Steps
  */
-async function When_I_set_request_headers(this, dataTable) {
+When(/^I set the request headers:$/, async function (dataTable) {
   const headers = {};
   dataTable.hashes().forEach(({ Header, Value }) => {
     headers[Header] = Value;
@@ -135,274 +108,236 @@ async function When_I_set_request_headers(this, dataTable) {
     ...this.config.headers,
     ...headers,
   };
-}
-When(/^I set the request headers:$/, When_I_set_request_headers);
+});
 
 /**
  * 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
  */
-async function When_I_set_endpoints_used(this, docString) {
+When(/^I set the following endpoints used:$/, async function (docString) {
   this.config.endpoints = docString
     .trim()
     .split("\n")
     .map((line) => line.trim());
-}
-When(/^I set the following endpoints used:$/, When_I_set_endpoints_used);
+});
 
 /**
  * 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}}" }
- * """
- * @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 (\w+) body is used for "([^"]+)"$/,
-  When_I_set_body_for_method_and_endpoint
+  async function (method, endpoint, docString) {
+    this.config.method = method.toUpperCase();
+    this.config.body = resolveBody(docString, process.env);
+    this.config.endpoint = endpoint;
+  }
 );
 
 /**
  * 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(
-        ", "
-      )}`
-    );
-  }
+When(
+  /^I use JSON payload from "([^"]+)" for (\w+) to "([^"]+)"$/,
+  async 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 projectRoot = path.resolve(__dirname, "..", "..");
-  const payloadDir = this.parameters?.payloadPath || "payloads";
-  const payloadPath = path.isAbsolute(payloadDir)
-    ? path.join(payloadDir, fileName)
-    : path.join(projectRoot, 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,
-    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,
-  };
-}
-When(
-  /^I use JSON payload from "([^"]+)" for (\w+) to "([^"]+)"$/,
-  When_I_use_JSON_payload
+    this.lastRequest = {
+      method: methodUpper,
+      endpoint,
+      body: resolved,
+    };
+  }
 );
 
 /**
  * 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"
- * @category K6 Steps
  */
-async function When_I_set_authentication_type(this, authType) {
+When(/^I set the authentication type to "([^"]+)"$/, async function (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
  */
-async function Then_I_store_value_as_alias(this, jsonPath, alias) {
-  if (!this.lastResponse) {
-    throw new Error("No previous response available.");
-  }
+Then(
+  /^I store the value at "([^"]+)" as alias "([^"]+)"$/,
+  async function (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);
-}
-Then(
-  /^I store the value at "([^"]+)" as alias "([^"]+)"$/,
-  Then_I_store_value_as_alias
+    console.log(`🧩 Stored alias "${alias}":`, value);
+  }
 );
 
 /**
  * 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}`);
-  }
-
-  const rawTemplate = fs.readFileSync(payloadPath, "utf-8");
-  const resolved = resolveBody(rawTemplate, {
-    ...process.env,
-    ...(this.aliases || {}),
-  });
+When(
+  /^I login via POST to "([^"]+)" with payload from "([^"]+)"$/,
+  async function (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;
-    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
-);
+      if (!response.ok) {
+        console.error("❌ Login request failed:", data);
+        throw new Error(`Login request failed with status ${response.status}`);
+      }
 
-/**
- * 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 POST request successfully
- * @category K6 Steps
- */
-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}`);
+      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");
     }
-  } catch (error) {
-    console.error("k6 execution failed:", error.stack || error);
-    throw new Error("k6 test execution failed");
   }
+);
+
+const genScriptDir = path.resolve(process.cwd(), "genScript");
+if (!fs.existsSync(genScriptDir)) {
+  fs.mkdirSync(genScriptDir, { recursive: true });
 }
+
+// Determine the report/output directory from env, CLI, or default to "reports"
+const reportDir =
+  process.env.REPORT_OUTPUT_DIR ||
+  process.env.K6_REPORT_DIR ||
+  (process.env.npm_config_report_output_dir || "reports");
+
+if (!fs.existsSync(reportDir)) {
+  fs.mkdirSync(reportDir, { recursive: true });
+}
+
 Then(
   /^I see the API should handle the (\w+) request successfully$/,
-  Then_I_see_API_should_handle_request
+  { 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 scriptPath = path.join(reportDir, `k6-script-${uniqueId}.js`);
+      fs.writeFileSync(scriptPath, scriptContent, "utf-8");
+      console.log(`✅ k6 script generated at: ${scriptPath}`);
+
+      // Always run k6 automatically, regardless of VU count
+      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}`);
+      }
+
+      // Remove the script unless saveK6Script is true in env/config/cli
+      const saveK6Script =
+        process.env.saveK6Script === "true" ||
+        process.env.SAVE_K6_SCRIPT === "true" ||
+        this.parameters?.saveK6Script === true;
+
+      if (!saveK6Script) {
+        try {
+          fs.unlinkSync(scriptPath);
+        } catch (cleanupErr) {
+          console.warn(`Warning: Could not delete temp script file: ${scriptPath}`);
+        }
+      } else {
+        console.log(`ℹ️  k6 script kept at: ${scriptPath}`);
+      }
+    } catch (error) {
+      console.error(
+        "Failed to generate or run k6 script:",
+        error.stack || error
+      );
+      throw new Error("k6 script generation or execution failed");
+    }
+  }
 );
+
+// Repeat this pattern for all other step definitions!

package/step_definitions/world.js

@@ -1,3 +1,4 @@
+//world.js
 const { setWorldConstructor } = require("@cucumber/cucumber");
 
 class CustomWorld {

package/scripts/generateHtmlReports.js

@@ -1,53 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const reporter = require("cucumber-html-reporter");
-
-function getJsonReportPath() {
-  // 1. Check for cucumber.js or custom config
-  const configFile = path.resolve("cucumber.js");
-  if (fs.existsSync(configFile)) {
-    const configText = fs.readFileSync(configFile, "utf-8");
-
-    const match = configText.match(/json:(.*?\.json)/);
-    if (match && match[1]) {
-      const reportPath = match[1].trim().replace(/['"`]/g, "");
-      console.log(`📝 Found report path in cucumber.js: ${reportPath}`);
-      return reportPath;
-    }
-  }
-
-  // 2. Check environment variable
-  if (process.env.CUCUMBER_JSON) {
-    console.log(
-      `📝 Using report path from CUCUMBER_JSON: ${process.env.CUCUMBER_JSON}`
-    );
-    return process.env.CUCUMBER_JSON;
-  }
-
-  // 3. Fallback to default
-  console.log("📝 Using default report path: reports/load-report.json");
-  return "reports/load-report.json";
-}
-
-function generateHtmlReports() {
-  const jsonReportPath = getJsonReportPath();
-
-  if (!fs.existsSync(jsonReportPath)) {
-    console.warn(`⚠️ Cucumber JSON report not found at: ${jsonReportPath}`);
-    return;
-  }
-
-  const reportDir = path.dirname(jsonReportPath);
-
-  reporter.generate({
-    theme: "bootstrap",
-    jsonFile: jsonReportPath,
-    output: path.join(reportDir, "cucumber-report.html"),
-    reportSuiteAsScenarios: true,
-    launchReport: false,
-    name: "k6-cucumber-steps Performance Report",
-    brandTitle: "📊 Performance Test Summary",
-  });
-}
-
-module.exports = { generateHtmlReports };