k6-cucumber-steps 1.0.26 → 1.0.28

package/README.md

@@ -7,7 +7,6 @@
 [![npm version](https://img.shields.io/npm/v/k6-cucumber-steps.svg)](https://www.npmjs.com/package/k6-cucumber-steps)
 [![npm downloads](https://img.shields.io/npm/dt/k6-cucumber-steps.svg)](https://www.npmjs.com/package/k6-cucumber-steps)
 [![license](https://img.shields.io/npm/l/k6-cucumber-steps)](https://github.com/qaPaschalE/k6-cucumber-steps/blob/main/LICENSE)
-
 [![Cucumber](https://img.shields.io/badge/built%20with-Cucumber-3178c6.svg)](https://cucumber.io/)
 [![Node.js](https://img.shields.io/badge/node-%3E=18-green.svg)](https://nodejs.org/)
 [![Sponsor](https://img.shields.io/github/sponsors/qaPaschalE?style=social)](https://github.com/sponsors/qaPaschalE)
@@ -20,13 +19,19 @@ Run [k6](https://k6.io/) performance/load tests using [Cucumber](https://cucumbe
 ## ✨ Features
 
 - ✅ Cucumber + Gherkin for writing k6 tests
+  to generate JSON and HTML reports.
+- ✅ Flexible configuration through Cucumber data tables.
 - ✅ Support for JSON body parsing and escaping
-- ✅ Faker support (`{{faker.name.firstName}}`)
+- ✅ Dynamic request body generation using environment variables, Faker templates, and JSON file includes.
 - ✅ `.env` + `K6.env`-style variable resolution (`{{API_KEY}}`)
 - ✅ Support for headers, query params, stages
+- ✅ Supports multiple authentication types: API key, Bearer token, Basic Auth, and No Auth.
+
 - ✅ Clean-up of temporary k6 files after execution
 - ✅ Built-in support for **distributed load testing** with stages
 - ✅ TypeScript-first 🧡
+- ✅ **Optional report overwriting**: Use the `overwrite` option to control whether reports are overwritten or appended.
+- ✅ **Generate detailed reports**: Use the `--reporter` flag
 
 ---
 
@@ -50,7 +55,8 @@ The `run` command accepts the following options:
 
 - `-f, --feature <path>`: Path to the feature file to execute.
 - `-t, --tags <string>`: Cucumber tags to filter scenarios (e.g., `@smoke and not @regression`).
-- `-r, --reporter`: Generate HTML and JSON reports in the `reports` directory. This is a boolean flag, so just include `-r` or `--reporter` to enable it.
+- `-r, --reporter`: Generate HTML and JSON reports in the `reports` directory. This is a boolean flag, so just include `-r, --reporter` to enable it.
+- `-o, --overwrite`: Overwrite existing reports instead of appending them.
 
 ### Example Usage with Options
 
@@ -117,6 +123,7 @@ Here's a step-by-step guide to using `k6-cucumber-steps` in your project:
         "html:reports/report.html", // For HTML report (requires @cucumber/html-formatter)
       ],
       tags: process.env.TAGS,
+      overwrite: false, // Default to not overwrite the report file
     };
     ```
 

package/bin/k6-cucumber-runner.js

@@ -8,21 +8,32 @@ const path = require("path");
 const { spawn } = require("child_process");
 require("dotenv").config();
 const argv = require("yargs")
-  .usage("Usage: $0 run [options]") // Removed the --feature requirement from usage
+  .usage("Usage: $0 run [options]")
   .option("feature", {
     alias: "f",
     describe: "Path to the feature file",
     type: "string",
-  }) // Keep the option but don't demand it
-  .option("tags", { alias: "t", describe: "Cucumber tags", type: "string" })
+  })
+  .option("tags", {
+    alias: "t",
+    describe: "Cucumber tags to filter scenarios (e.g., @smoke)",
+    type: "string",
+  })
   .option("reporter", {
     alias: "r",
-    describe: "Generate reports",
+    describe: "Generate HTML and JSON reports in the `reports` directory",
+    type: "boolean",
+    default: false,
+  })
+  .option("overwrite", {
+    alias: "o",
+    describe: "Overwrite existing reports instead of appending them",
     type: "boolean",
     default: false,
   })
   .help().argv;
 
+// Base Cucumber command and arguments
 const cucumberCommand = "npx";
 const cucumberArgs = [
   "cucumber-js",
@@ -36,39 +47,72 @@ const cucumberArgs = [
     "step_definitions"
   ),
   "--require",
-  path.resolve(process.cwd(), "step_definitions"), // Keep the user's local step definitions as well
+  path.resolve(process.cwd(), "step_definitions"), // Include user's local step definitions
   "--format",
   "summary",
   "--format",
-  "progress", // Add this line
+  "progress", // Progress bar format
 ];
 
-const tagsFromEnv = process.env.TAGS || " ";
-cucumberArgs.push("--tags", tagsFromEnv);
+// Add tags from CLI or environment variables
+if (argv.tags) {
+  cucumberArgs.push("--tags", argv.tags);
+} else if (process.env.TAGS) {
+  cucumberArgs.push("--tags", process.env.TAGS);
+}
 
+// Add feature file if provided
 if (argv.feature) {
   cucumberArgs.push(path.resolve(process.cwd(), argv.feature));
 }
 
+// Add reporting options if enabled
 if (argv.reporter) {
   const reportsDir = path.resolve(process.cwd(), "reports");
+  try {
+    require("fs").mkdirSync(reportsDir, { recursive: true }); // Ensure reports directory exists
+  } catch (err) {
+    console.error(`Failed to create reports directory: ${err.message}`);
+    process.exit(1);
+  }
   cucumberArgs.push(
     "--format",
-    `json:${reportsDir}/load-results.json`,
+    `json:${path.join(reportsDir, "load-results.json")}`,
     "--format",
-    `html:${reportsDir}/load-results.html`
+    `html:${path.join(reportsDir, "load-results.html")}`
   );
 }
 
+/**
+ * Main function to execute the Cucumber process.
+ */
 async function main() {
-  const cucumberProcess = spawn(cucumberCommand, cucumberArgs, {
-    cwd: process.cwd(),
-    stdio: "inherit",
-  });
+  try {
+    const cucumberProcess = spawn(cucumberCommand, cucumberArgs, {
+      cwd: process.cwd(),
+      stdio: "inherit", // Inherit stdout/stderr for real-time logging
+      env: {
+        ...process.env,
+        K6_CUCUMBER_OVERWRITE: argv.overwrite, // Pass overwrite flag to environment
+      },
+    });
 
-  cucumberProcess.on("close", (code) => {
-    process.exit(code);
-  });
+    cucumberProcess.on("close", (code) => {
+      if (code === 0) {
+        console.log("-----------------------------------------");
+        console.log("✅ k6-cucumber-steps execution completed successfully.");
+        console.log("-----------------------------------------");
+      } else {
+        console.error("-----------------------------------------");
+        console.error("❌ k6-cucumber-steps execution failed.");
+        console.error("-----------------------------------------");
+      }
+      process.exit(code);
+    });
+  } catch (error) {
+    console.error("An unexpected error occurred:", error.message);
+    process.exit(1);
+  }
 }
 
 main().catch((err) => console.error(err));

package/cucumber.js

@@ -4,10 +4,11 @@ module.exports = {
   require: ["./step_definitions/**/*.js"],
   format: [
     "summary",
-    "json:reports/load-report.json",
-    "html:reports/report.html",
+    "json:src/examples/reports/load-report.json",
+    "html:src/examples/reports/report.html",
   ],
   // Specify the path to your features folder here
-  paths: ["./features"],
+  paths: ["./src/examples/features/loadTestTemplate.feature"],
   tags: "@loadTest", // Default tag for load tests
+  overwrite: false, // Default to not overwrite the report file
 };

package/lib/utils/k6Runner.js

@@ -8,15 +8,33 @@ 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='load'] - Type of script (e.g., 'load').
+ * @param {boolean} [overwrite=false] - Whether to overwrite the report file.
  * @returns {Promise<string>} - Path to the generated k6 script file.
  */
-const generateK6Script = async (scriptContent, scriptType = "load") => {
+const generateK6Script = async (
+  scriptContent,
+  scriptType = "load",
+  overwrite = false
+) => {
   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;
+
+  try {
+    await fs.mkdir(tempDir, { recursive: true }); // Ensure temp directory exists
+
+    // Write the script content based on the overwrite flag
+    if (overwrite) {
+      await fs.writeFile(scriptPath, scriptContent, { flag: "w" }); // Overwrite mode
+    } else {
+      await fs.appendFile(scriptPath, scriptContent); // Append mode
+    }
+
+    return scriptPath;
+  } catch (error) {
+    console.error(`Error generating k6 script: ${error.message}`);
+    throw error;
+  }
 };
 
 /**
@@ -29,9 +47,10 @@ 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<string>} - Standard output from k6 execution.
  */
-const runK6Script = async (scriptPath) => {
+const runK6Script = async (scriptPath, overwrite = false) => {
   // ANSI escape codes for colors
   const chalkGreen = "\x1b[38;2;0;255;0m"; // Green
   const chalkYellow = "\x1b[38;2;255;255;0m"; // Yellow

package/package.json

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

package/step_definitions/load_test_steps.js

@@ -174,11 +174,23 @@ Then(
       );
     }
     try {
+      // Generate the k6 script content
       const scriptContent = buildK6Script(this.config);
-      const scriptPath = await generateK6Script(scriptContent);
-      const stdout = await runK6Script(scriptPath);
+
+      // Generate the temporary k6 script file with overwrite option
+      const scriptPath = await generateK6Script(
+        scriptContent,
+        "load",
+        this.overwrite
+      );
+
+      // Run the k6 script with overwrite option
+      const stdout = await runK6Script(scriptPath, this.overwrite);
+
+      console.log(stdout);
     } catch (error) {
       console.error("k6 execution failed:", error.message);
+      console.error("k6 stderr:", error.stderr); // Log stderr for debugging
       throw new Error("k6 test execution failed");
     }
   }

package/step_definitions/world.js

@@ -1,12 +1,16 @@
-const { setWorldConstructor } = require('@cucumber/cucumber');
+const { setWorldConstructor } = require("@cucumber/cucumber");
 
 class CustomWorld {
-  constructor() {
+  constructor({ parameters }) {
     this.options = {};
     this.configurations = {};
     this.endpoints = [];
-    this.authType = '';
+    this.authType = "";
     this.postBody = {};
+    this.overwrite =
+      parameters?.overwrite ||
+      process.env.K6_CUCUMBER_OVERWRITE === "true" ||
+      false;
   }
 }