k6-cucumber-steps 1.2.20 → 1.2.22

package/lib/helpers/buildK6Script.js

@@ -1,4 +1,4 @@
-module.exports = function buildK6Script(config) {
+export default function buildK6Script(config) {
   const { method, endpoints, endpoint, body, headers, options, baseUrl } =
     config;
 
@@ -83,4 +83,4 @@ export function handleSummary(data) {
   };
 }
 `;
-};
+}

package/lib/helpers/generateHeaders.js

@@ -1,35 +1,48 @@
 /**
  * @module generateHeaders
  * @description
- * This module generates HTTP headers for API requests based on the specified authentication type.
- * It supports API key, bearer token, basic authentication, and no authentication.
- * Generates HTTP headers based on the specified authentication type.
- * Supported auth types: api_key, bearer_token, basic, none.
+ * Generates HTTP headers for API requests based on the specified authentication type.
+ * Supports: api_key, bearer_token, basic, none, and alias-based token resolution.
  */
-module.exports = function generateHeaders(authType, env, aliases = {}) {
+
+export default 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"] = getValue("API_KEY");
-  } else if (authType === "bearer_token") {
-    headers["Authorization"] = `Bearer ${getValue("token")}`;
-  } else if (authType === "basic") {
-    const base64 = Buffer.from(
-      `${getValue("BASIC_USER")}:${getValue("BASIC_PASS")}`
-    ).toString("base64");
-    headers["Authorization"] = `Basic ${base64}`;
-  } else if (authType === "none") {
-    // No auth, just default content-type
-  } else if (aliases[authType]) {
-    // ✅ Custom alias support
-    headers["Authorization"] = `Bearer ${getValue(authType)}`;
-  } else {
-    throw new Error(
-      `Unsupported authentication type or missing alias: ${authType}`
-    );
+  switch (authType) {
+    case "api_key":
+      headers["x-api-key"] = getValue("API_KEY");
+      break;
+
+    case "bearer_token":
+      headers["Authorization"] = `Bearer ${getValue("token")}`;
+      break;
+
+    case "basic":
+      const user = getValue("BASIC_USER");
+      const pass = getValue("BASIC_PASS");
+      if (!user || !pass) {
+        throw new Error("Missing BASIC_USER or BASIC_PASS for basic auth.");
+      }
+      headers["Authorization"] = `Basic ${Buffer.from(
+        `${user}:${pass}`
+      ).toString("base64")}`;
+      break;
+
+    case "none":
+      // Only content-type
+      break;
+
+    default:
+      if (aliases[authType]) {
+        headers["Authorization"] = `Bearer ${getValue(authType)}`;
+      } else {
+        throw new Error(
+          `Unsupported authentication type or missing alias: ${authType}`
+        );
+      }
   }
 
   return headers;
-};
+}

package/lib/helpers/runK6ScriptFromWorld.js

@@ -1,15 +1,4 @@
-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) {
+export async function runK6ScriptFromWorld(world, method, isMulti = false) {
   const scriptContent = buildK6Script({
     method,
     endpoint: isMulti ? undefined : world.endpoint,
@@ -32,5 +21,3 @@ async function runK6ScriptFromWorld(world, method, isMulti = false) {
 
   console.log("✅ K6 script ran successfully.");
 }
-
-module.exports = runK6ScriptFromWorld;

package/lib/utils/k6Runner.js

@@ -1,8 +1,13 @@
-const path = require("path");
-const { exec } = require("child_process");
-const { v4: uuidv4 } = require("uuid");
-const fs = require("fs").promises; // Use promises for cleaner async/await
-const packageJson = require("../../package.json"); // Access package version
+import path from "path";
+import { exec } from "child_process";
+import { v4 as uuidv4 } from "uuid";
+import { promises as fs } from "fs";
+import { fileURLToPath } from "url";
+import packageJson from "../../package.json" assert { type: "json" };
+
+// __dirname workaround for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 /**
  * Generates a temporary k6 script file.
@@ -11,23 +16,22 @@ const packageJson = require("../../package.json"); // Access package version
  * @param {boolean} [overwrite=false] - Whether to overwrite the report file.
  * @returns {Promise<string>} - Path to the generated k6 script file.
  */
-const generateK6Script = async (
+export async function generateK6Script(
   scriptContent,
   scriptType = "load",
   overwrite = false
-) => {
+) {
   const tempDir = path.resolve(__dirname, "../../temp");
   const scriptName = `${scriptType}_script_${uuidv4()}.js`;
   const scriptPath = path.join(tempDir, scriptName);
 
   try {
-    await fs.mkdir(tempDir, { recursive: true }); // Ensure temp directory exists
+    await fs.mkdir(tempDir, { recursive: true });
 
-    // Write the script content based on the overwrite flag
     if (overwrite) {
-      await fs.writeFile(scriptPath, scriptContent, { flag: "w" }); // Overwrite mode
+      await fs.writeFile(scriptPath, scriptContent, { flag: "w" });
     } else {
-      await fs.appendFile(scriptPath, scriptContent); // Append mode
+      await fs.appendFile(scriptPath, scriptContent);
     }
 
     return scriptPath;
@@ -35,51 +39,45 @@ const generateK6Script = async (
     console.error(`Error generating k6 script: ${error.message}`);
     throw error;
   }
-};
+}
 
 /**
  * Introduce a delay in milliseconds.
- * @param {number} ms - The duration of the delay in milliseconds.
- * @returns {Promise<void>} - A Promise that resolves after the delay.
+ * @param {number} ms - Duration of the delay.
+ * @returns {Promise<void>}
  */
-const delay = (ms) => new Promise((res) => setTimeout(res, ms));
+export const delay = (ms) => new Promise((res) => setTimeout(res, ms));
 
 /**
  * Runs the k6 script with custom branding.
  * @param {string} scriptPath - Path to the k6 script file.
  * @param {boolean} [overwrite=false] - Whether to overwrite the report file.
- * @returns {Promise<{stdout: string, stderr: string, code: number}>} - k6 execution result.
+ * @returns {Promise<{stdout: string, stderr: string, code: number}>}
  */
-const runK6Script = async (scriptPath, overwrite = false) => {
-  const chalkGreen = "\x1b[38;2;0;255;0m"; // Green
-  const chalkYellow = "\x1b[38;2;255;255;0m"; // Yellow
+export async function runK6Script(scriptPath, overwrite = false) {
+  const chalkGreen = "\x1b[38;2;0;255;0m";
+  const chalkYellow = "\x1b[38;2;255;255;0m";
   const resetColor = "\x1b[0m";
 
-  // Custom logo with version information
   const customLogo = `${chalkGreen} with @qaPaschalE's ${chalkYellow}k6-cucumber-steps v${packageJson.version}${resetColor}`;
 
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
     exec(`k6 run "${scriptPath}"`, async (error, stdout, stderr) => {
-      // Split the k6 logo lines
       const logoLines = stdout.split("\n");
 
-      // Insert the custom logo under "Grafana" (on the third line)
       let modifiedStdout = "";
       for (let i = 0; i < logoLines.length; i++) {
         modifiedStdout += logoLines[i];
         if (i === 5) {
-          // Target the third line (index 2) of the k6 logo
           modifiedStdout += `   ${customLogo}\n`;
         }
         modifiedStdout += "\n";
       }
 
-      // Clean up the temporary script file
       fs.unlink(scriptPath).catch((err) =>
         console.error("Error deleting temporary k6 script:", err)
       );
 
-      // Always resolve with all outputs and code
       resolve({
         stdout: modifiedStdout,
         stderr,
@@ -87,6 +85,4 @@ const runK6Script = async (scriptPath, overwrite = false) => {
       });
     });
   });
-};
-
-module.exports = { generateK6Script, runK6Script };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k6-cucumber-steps",
-  "version": "1.2.20",
+  "version": "1.2.22",
   "main": "index.js",
   "license": "MIT",
   "repository": {
@@ -10,6 +10,7 @@
   "bugs": {
     "url": "https://github.com/qaPaschalE/k6-cucumber-steps/issues"
   },
+  "type": "module",
   "funding": {
     "type": "github",
     "url": "https://github.com/sponsors/qaPaschalE"

package/step_definitions/load_test_steps.js

@@ -1,8 +1,13 @@
 // e2e/step_definitions/load_test_steps.js
 
 import { Given, When, Then } from "@cucumber/cucumber";
-import fs from "fs";
 import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 import crypto from "crypto";
 import * as dotenv from "dotenv";
 import resolvePayloadPath from "../lib/helpers/resolvePayloadPath.js";
@@ -10,7 +15,7 @@ import resolveBody from "../lib/helpers/resolveBody.js";
 // import buildK6Script from "../lib/helpers/buildK6Script.js";
 import generateHeaders from "../lib/helpers/generateHeaders.js";
 // import { runK6Script } from "../lib/utils/k6Runner.js";
-const runK6ScriptFromWorld = require("../../../helpers/runK6ScriptFromWorld");
+import { runK6ScriptFromWorld } from "../../../helpers/runK6ScriptFromWorld.js";
 
 dotenv.config();
 
@@ -346,7 +351,10 @@ export async function When_I_set_method_body_for_endpoint(
     )}...`
   );
 }
-
+When(
+  /^I set the following (\w+) body is used for "([^"]+)"$/,
+  When_I_set_method_body_for_endpoint
+);
 /**
  * Loads a JSON payload from a file to be used as the request body for a specific
  * method and endpoint in the k6 script.