k6-cucumber-steps 1.2.21 → 1.2.23

package/bin/k6-cucumber-steps.js

@@ -1,11 +1,17 @@
 #!/usr/bin/env node
-const path = require("path");
-const fs = require("fs");
-const { spawn } = require("child_process");
-const { Command } = require("commander");
-require("dotenv").config();
+import path from "path";
+import fs from "fs/promises";
+import { spawn } from "child_process";
+import { Command } from "commander";
+import { fileURLToPath } from "url";
+import dotenv from "dotenv";
+import { linkReports } from "../scripts/linkReports.js";
 
-const { linkReports } = require("../scripts/linkReports");
+dotenv.config();
+
+// Allow __dirname in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 console.log(`
   -----------------------------------------
@@ -26,9 +32,9 @@ program
   .option("--reporter", "Enable report generation", false)
   .option("--clean", "Alias for --cleanReports", false)
   .option("-p, --payloadPath <dir>", "Directory for payload files")
-  // Add CLI options for all config options
+  .option("--script <file>", "k6 script file to run")
+  .option("--k6Config <file>", "k6 config file to use")
   .action(async (argv) => {
-    // Load config file
     const configFileInput =
       argv.config || process.env.CUCUMBER_CONFIG_FILE || "cucumber.js";
     const configFilePath = path.isAbsolute(configFileInput)
@@ -36,20 +42,16 @@ program
       : path.resolve(process.cwd(), configFileInput);
 
     let configOptions = {};
-    if (fs.existsSync(configFilePath)) {
-      try {
-        const loadedConfig = require(configFilePath);
-        configOptions = loadedConfig.default || loadedConfig;
-      } catch (err) {
-        console.warn("⚠️ Could not load config file:", err.message);
-      }
+    try {
+      const configModule = await import(pathToFileURL(configFilePath).href);
+      configOptions = configModule.default || configModule;
+    } catch (err) {
+      console.warn("⚠️ Could not load config file:", err.message);
     }
 
-    // Build the cucumber-js command from config
     const cucumberConfig = configOptions.default || configOptions;
-    let cliParts = [];
+    const cliParts = [];
 
-    // Add paths
     if (cucumberConfig.paths && Array.isArray(cucumberConfig.paths)) {
       cliParts.push(...cucumberConfig.paths);
     }
@@ -57,21 +59,14 @@ program
       cliParts.push(argv.feature);
     }
 
-    // Add require
     if (cucumberConfig.require && Array.isArray(cucumberConfig.require)) {
-      cucumberConfig.require.forEach((req) => {
-        cliParts.push("--require", req);
-      });
+      cucumberConfig.require.forEach((req) => cliParts.push("--require", req));
     }
 
-    // Add format
     if (cucumberConfig.format && Array.isArray(cucumberConfig.format)) {
-      cucumberConfig.format.forEach((fmt) => {
-        cliParts.push("--format", fmt);
-      });
+      cucumberConfig.format.forEach((fmt) => cliParts.push("--format", fmt));
     }
 
-    // Add tags
     if (cucumberConfig.tags) {
       cliParts.push("--tags", cucumberConfig.tags);
     }
@@ -79,26 +74,23 @@ program
       cliParts.push("--tags", argv.tags);
     }
 
-    // Determine project root (where your main package.json is)
     const projectRoot = process.cwd();
 
-    // Determine payload directory from CLI or config, always relative to project root
     let payloadDirRaw =
       argv.payloadPath ||
       (cucumberConfig.worldParameters &&
         cucumberConfig.worldParameters.payloadPath) ||
       "payloads";
+
     const payloadDir = path.resolve(projectRoot, payloadDirRaw);
     console.log("📦 Resolved payload path:", payloadDir);
 
-    // Add --world-parameters to CLI args
     const worldParams = {
       ...(cucumberConfig.worldParameters || {}),
       payloadPath: payloadDir,
     };
     cliParts.push("--world-parameters", JSON.stringify(worldParams));
 
-    // Add CLI options for k6 script and config
     if (argv.script) {
       cliParts.push("--script", argv.script);
     }
@@ -107,12 +99,9 @@ program
     }
 
     const finalCommand = ["npx", "cucumber-js", ...cliParts].join(" ");
-
     console.log("▶️ Final arguments passed to cucumber-js:", finalCommand);
 
-    // Collect options to pass as env vars
     const extraEnv = {
-      // Priority: cucumberConfig > CLI
       SAVE_K6_SCRIPT:
         cucumberConfig.saveK6Script === true || argv.saveK6Script === true
           ? "true"
@@ -133,19 +122,19 @@ program
           : "false",
     };
 
-    // Clean reports directory if requested
     const shouldCleanReports =
       argv.cleanReports || argv.clean || cucumberConfig.cleanReports;
 
     if (shouldCleanReports) {
       const reportsDir = path.join(projectRoot, "reports");
-      if (fs.existsSync(reportsDir)) {
-        fs.rmSync(reportsDir, { recursive: true, force: true });
-        fs.mkdirSync(reportsDir, { recursive: true });
+      try {
+        await fs.rm(reportsDir, { recursive: true, force: true });
+        await fs.mkdir(reportsDir, { recursive: true });
+      } catch (err) {
+        console.error("Failed to clean reports folder:", err.message);
       }
     }
 
-    // Now spawn the process
     const cucumberProcess = spawn("npx", ["cucumber-js", ...cliParts], {
       stdio: "inherit",
       env: { ...process.env, ...extraEnv },
@@ -174,3 +163,9 @@ program
   });
 
 program.parse(process.argv);
+
+// Helper to handle dynamic import path
+function pathToFileURL(p) {
+  const url = new URL("file://" + path.resolve(p));
+  return url;
+}

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.21",
+  "version": "1.2.23",
   "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();