k6-cucumber-steps 1.0.11 → 1.0.13

package/.env

@@ -10,7 +10,7 @@ TAGS=@loadTest
 # Base URLs
 # API_URL=https://unstable-performance.seamlesshrms.com
 # BASE_URL=https://unstable-performance.seamlesshrms.com
-BASE_URL=https://reqres.in
+BASE_URL=https://postman-echo.com
 
 # Secret Parameters
 API_KEY=Talent123!

package/bin/k6-cucumber-runner.js

@@ -1,57 +1,75 @@
 #!/usr/bin/env node
 
+console.log("-----------------------------------------");
+console.log("🚀 Starting k6-cucumber-steps execution...");
+console.log("-----------------------------------------");
+
 const path = require("path");
-const { runCucumber } = require("@cucumber/cucumber/api");
+const { spawn } = require("child_process");
 require("dotenv").config();
-
 const argv = require("yargs")
-  .usage("Usage: $0 run --feature <path> [options]")
+  .usage("Usage: $0 run [options]") // Removed the --feature requirement from usage
   .option("feature", {
     alias: "f",
     describe: "Path to the feature file",
     type: "string",
-    demandOption: true,
+  }) // Keep the option but don't demand it
+  .option("tags", { alias: "t", describe: "Cucumber tags", type: "string" })
+  .option("reporter", {
+    alias: "r",
+    describe: "Generate reports",
+    type: "boolean",
+    default: false,
   })
   .help().argv;
 
-const featureFilePath = path.resolve(process.cwd(), argv.feature);
+const cucumberCommand = "npx";
+const cucumberArgs = [
+  "cucumber-js",
+  "--require-module",
+  "@babel/register",
+  "--require",
+  path.resolve(
+    process.cwd(),
+    "node_modules",
+    "k6-cucumber-steps",
+    "step_definitions"
+  ),
+  "--require",
+  path.resolve(process.cwd(), "step_definitions"), // Keep the user's local step definitions as well
+  "--format",
+  "summary",
+  "--format",
+  "cucumber-console-formatter", // Add this line
+];
+
+// Explicitly add tags, defaulting to '@loadTest' if no TAGS env variable is set
+const tagsFromEnv = process.env.TAGS || "@loadTest";
+cucumberArgs.push("--tags", tagsFromEnv);
+
+if (argv.feature) {
+  cucumberArgs.push(path.resolve(process.cwd(), argv.feature));
+}
+
+if (argv.reporter) {
+  const reportsDir = path.resolve(process.cwd(), "reports");
+  cucumberArgs.push(
+    "--format",
+    `json:${reportsDir}/load-results.json`,
+    "--format",
+    `html:${reportsDir}/load-results.html`
+  );
+}
 
 async function main() {
-  try {
-    console.log(`Running tests for feature file: ${featureFilePath}`);
-
-    const result = await runCucumber({
-      argv: [
-        "node",
-        "cucumber-js",
-        "--require-module",
-        "@babel/register",
-        "--require",
-        path.resolve(
-          process.cwd(),
-          "node_modules",
-          "k6-cucumber-steps",
-          "step_definitions"
-        ),
-      ],
-      cwd: process.cwd(),
-      featurePaths: [featureFilePath],
-      format: ["summary"],
-    });
-
-    if (!result.success) {
-      console.error("K6 Cucumber tests failed.");
-      process.exit(1);
-    }
-
-    console.log("K6 Cucumber tests finished successfully.");
-  } catch (error) {
-    console.error("An error occurred during K6 Cucumber execution:", error);
-    process.exit(1);
-  }
+  const cucumberProcess = spawn(cucumberCommand, cucumberArgs, {
+    cwd: process.cwd(),
+    stdio: "inherit",
+  });
+
+  cucumberProcess.on("close", (code) => {
+    process.exit(code);
+  });
 }
 
-main().catch((err) => {
-  console.error("An unexpected error occurred:", err);
-  process.exit(1);
-});
+main().catch((err) => console.error(err));

package/cucumber.js

@@ -1,26 +1,13 @@
-/**
- * @module cucumber
- * @description
- * This module configures the Cucumber.js test runner for load testing with k6.
- * It specifies the paths to feature files, step definitions, and the output format.
- * It also sets the timeout for each test and allows for filtering tests by tags.
- */
-const reporter = require("cucumber-html-reporter");
+// cucumber.js
+
 module.exports = {
-  default: {
-    require: ["step_definitions/world.js", "step_definitions/*.js"],
-    paths: ["src/examples/features/*.feature"],
-    format: ["progress", "json:reports/load-results.json"],
-    timeout: 60000,
-    tags: process.env.TAGS || "@loadTest",
-  },
+  require: ["./step_definitions/**/*.js"],
+  format: [
+    "summary",
+    "json:reports/load-report.json",
+    "html:reports/report.html",
+  ],
+  // Specify the path to your features folder here
+  paths: ["./features"],
+  tags: "@loadTest", // Default tag for load tests
 };
-
-// // Generate an HTML report after tests complete
-// reporter.generate({
-//   theme: "bootstrap",
-//   jsonFile: "reports/load-results.json",
-//   output: "reports/report.html",
-//   reportSuiteAsScenarios: true,
-//   scenarioTimestamp: true,
-// });

package/lib/helpers/buildK6Script.js

@@ -1,34 +1,5 @@
-/**
- * @module generateHeaders
- * @description
- * This module generates HTTP headers for API requests based on the specified authentication type.
- * It supports API key, bearer token, and basic authentication.
- * Generates HTTP headers based on the specified authentication type.
- * Supported auth types: api_key, bearer_token, basic.
- * @param {string} authType - The type of authentication to use.
- * @param {object} env - The environment variables object.
- * @returns {object} - The generated headers object.
- * @throws {Error} - If the authentication type is unsupported.
- * @example
- * const headers = generateHeaders('api_key', process.env);
- * // headers will contain the API key in the x-api-key header.
- * @example
- * const headers = generateHeaders('bearer_token', process.env);
- * // headers will contain the bearer token in the Authorization header.
- * @example
- * const headers = generateHeaders('basic', process.env);
- * // headers will contain the basic auth credentials in the Authorization header.
- * @example
- * const headers = generateHeaders('none', process.env);
- * // headers will contain only the Content-Type header.
- * @example
- * const headers = generateHeaders('invalid_auth_type', process.env);
- * // throws an error: Unsupported authentication type: invalid_auth_type
- */
-
 module.exports = function buildK6Script(config) {
   const { method, endpoints, endpoint, body, headers, options } = config;
-  console.log("Generating k6 script with config:", config);
   // Ensure at least one of `endpoints` or `endpoint` is defined
   if (!endpoints?.length && !endpoint) {
     throw new Error(

package/lib/utils/k6Runner.js

@@ -1,71 +1,87 @@
-import fs from "fs";
-import path from "path";
-import { v4 as uuidv4 } from "uuid";
-import { spawn } from "child_process";
+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
 
 /**
  * Generates a temporary k6 script file.
  * @param {string} scriptContent - The content of the k6 script.
- * @param {string} scriptType - The type of script (default: "k6").
- * @returns {string} - The path to the generated temporary script file.
+ * @param {string} [scriptType='load'] - Type of script (e.g., 'load').
+ * @returns {Promise<string>} - Path to the generated k6 script file.
  */
-export function generateK6Script(scriptContent, scriptType = "k6") {
-  const tempFileName = `${scriptType}_script_${uuidv4()}.js`;
-  const tempFilePath = path.join(process.cwd(), "tmp", tempFileName);
-
-  // Ensure the directory exists and write the script content
-  fs.mkdirSync(path.dirname(tempFilePath), { recursive: true });
-  fs.writeFileSync(tempFilePath, scriptContent);
-  return tempFilePath;
-}
+const generateK6Script = async (scriptContent, scriptType = "load") => {
+  const tempDir = path.resolve(__dirname, "../../temp");
+  const scriptName = `${scriptType}_script_${uuidv4()}.js`;
+  const scriptPath = path.join(tempDir, scriptName);
+  await fs.mkdir(tempDir, { recursive: true }); // Ensure temp directory exists
+  await fs.writeFile(scriptPath, scriptContent, "utf8");
+  return scriptPath;
+};
 
 /**
- * Runs the k6 script using the `k6 run` command.
- * @param {string} scriptPath - The path to the k6 script file.
- * @returns {Promise<string>} - Resolves with the stdout of the k6 execution.
+ * 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.
  */
+const delay = (ms) => new Promise((res) => setTimeout(res, ms));
 
-export async function runK6Script(scriptPath) {
-  return new Promise((resolve, reject) => {
-    const k6Process = spawn("k6", ["run", scriptPath]);
+/**
+ * Runs the k6 script with custom branding.
+ * @param {string} scriptPath - Path to the k6 script file.
+ * @returns {Promise<string>} - Standard output from k6 execution.
+ */
+const runK6Script = async (scriptPath) => {
+  // ANSI escape codes for colors
+  const chalkGreen = "\x1b[38;2;0;255;0m"; // Green
+  const chalkYellow = "\x1b[38;2;255;255;0m"; // Yellow
+  const resetColor = "\x1b[0m";
 
-    let stdout = "";
-    let stderr = "";
+  // Custom logo with version information
+  const customLogo = `${chalkGreen} with @qaPaschalE's ${chalkYellow}k6-cucumber-steps v${packageJson.version}${resetColor}`;
 
-    // Capture stdout and log it in real-time
-    k6Process.stdout.on("data", (data) => {
-      stdout += data.toString();
-      console.log(data.toString()); // Log output in real-time
-    });
+  return new Promise(async (resolve, reject) => {
+    exec(
+      `k6 run --vus 1 --iterations 1 "${scriptPath}"`,
+      async (error, stdout, stderr) => {
+        // Split the k6 logo lines
+        const logoLines = stdout.split("\n");
 
-    // Capture stderr and log it in real-time
-    k6Process.stderr.on("data", (data) => {
-      stderr += data.toString();
-      console.error(data.toString()); // Log errors in real-time
-    });
+        // 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";
+        }
 
-    // Handle process exit
-    k6Process.on("close", (code) => {
-      // Always clean up temp file
-      fs.unlink(scriptPath, (unlinkErr) => {
-        if (unlinkErr) {
-          console.warn(`Failed to delete temp script: ${unlinkErr.message}`);
+        // Handle errors and cleanup
+        if (error) {
+          console.error("k6 error:", error);
+          console.error("k6 stdout:", modifiedStdout);
+          await delay(3000); // Wait for 3 seconds
+          console.error("k6 stderr:", stderr);
+          reject(new Error(`k6 test execution failed: ${error.message}`));
+        } else if (stderr) {
+          console.log("k6 stdout:", modifiedStdout);
+          await delay(3000); // Wait for 3 seconds
+          resolve(stdout);
+        } else {
+          console.log("k6 stdout:", modifiedStdout);
+          await delay(3000); // Wait for 3 seconds
+          resolve(stdout);
         }
-      });
 
-      if (code !== 0) {
-        console.error("k6 run failed with code:", code);
-        console.error("stderr:", stderr);
-        reject(new Error(`k6 run failed with code ${code}: ${stderr}`));
-      } else {
-        resolve(stdout);
+        // Clean up the temporary script file
+        fs.unlink(scriptPath).catch((err) =>
+          console.error("Error deleting temporary k6 script:", err)
+        );
       }
-    });
-
-    // Handle spawn errors
-    k6Process.on("error", (err) => {
-      console.error("Failed to start k6 process:", err.message);
-      reject(err);
-    });
+    );
   });
-}
+};
+
+module.exports = { generateK6Script, runK6Script };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "k6-cucumber-steps",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "main": "index.js",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/qaPaschalE/k6-cucumber-steps.git"
@@ -43,7 +44,6 @@
     "node": ">=18"
   },
   "author": "qaPaschalE",
-  "license": "ISC",
   "description": "Cucumber step definitions for running k6 performance tests.",
   "devDependencies": {
     "@babel/cli": "^7.27.0",
@@ -51,6 +51,7 @@
     "@babel/preset-env": "^7.26.9",
     "@types/k6": "^1.0.2",
     "child_process": "^1.0.2",
+    "cucumber-console-formatter": "^1.0.0",
     "cucumber-html-reporter": "^6.0.0",
     "esbuild": "^0.25.3",
     "form-data": "^4.0.2",