k6-cucumber-steps 1.0.28 → 1.0.30

package/.github/workflows/k6-load-test.yml

@@ -1,8 +1,7 @@
 name: build
 
 on:
-  push:
-    branches: ["main"]
+  workflow_dispatch:
 
 jobs:
   release:

package/README.md

@@ -110,17 +110,17 @@ Here's a step-by-step guide to using `k6-cucumber-steps` in your project:
     Create a `cucumber.js` file at the root of your project with the following content:
 
     ```javascript
-    // cucumber.js
-    require("dotenv").config();
+    // cucumber.js as default name but you can optionally give it any name of choice
 
     module.exports = {
       require: [
         // You can add paths to your local step definitions here if needed
       ],
+      reporter:true // To provide HTML and JSON report
       format: [
         "summary",
         "json:reports/load-report.json", // For JSON report
-        "html:reports/report.html", // For HTML report (requires @cucumber/html-formatter)
+        "html:reports/report.html", // For HTML report
       ],
       tags: process.env.TAGS,
       overwrite: false, // Default to not overwrite the report file
@@ -129,16 +129,16 @@ Here's a step-by-step guide to using `k6-cucumber-steps` in your project:
 
 **Running Tests:**
 
-From the root of your project, use the CLI command:
+From the root of your project, use the CLI command for default config:
 
 ```bash
 npx k6-cucumber-steps run
 ```
 
-You can also specify a feature file or tags:
+You can also specify a configFile:
 
 ```bash
-npx k6-cucumber-steps run --feature features/example.feature -t "@yourTag"
+npx k6-cucumber-steps run --configFile cucumber.prod.js
 ```
 
 ---

package/bin/k6-cucumber-steps.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const fs = require("fs");
+const { spawn } = require("child_process");
+const yargs = require("yargs");
+require("dotenv").config();
+
+// 🚀 Welcome Message
+console.log(`
+  -----------------------------------------
+  🚀 Starting k6-cucumber-steps execution...
+  -----------------------------------------
+`);
+
+const argv = yargs
+  .usage("Usage: $0 run [options]")
+  .option("feature", {
+    alias: "f",
+    describe: "Path to the feature file",
+    type: "string",
+  })
+  .option("tags", {
+    alias: "t",
+    describe: "Cucumber tags to filter scenarios",
+    type: "string",
+  })
+  .option("reporter", {
+    alias: "r",
+    describe: "Enable HTML and JSON reports",
+    type: "boolean",
+    default: false,
+  })
+  .option("overwrite", {
+    alias: "o",
+    describe: "Overwrite existing reports",
+    type: "boolean",
+    default: false,
+  })
+  .option("configFile", {
+    alias: "c",
+    describe: "Custom cucumber config file",
+    type: "string",
+  })
+  .help().argv;
+
+const cucumberArgs = ["cucumber-js"];
+
+const configFileName =
+  argv.configFile || process.env.CUCUMBER_CONFIG_FILE || "cucumber.js";
+const configFilePath = path.resolve(process.cwd(), configFileName);
+
+console.log(`🔍 Looking for config file: ${configFileName}`);
+console.log(`📁 Resolved config file path: ${configFilePath}`);
+
+let configOptions = {};
+if (fs.existsSync(configFilePath)) {
+  console.log("✅ Config file found, including in cucumber arguments...");
+  cucumberArgs.push("--config", configFileName);
+
+  try {
+    const loadedConfig = require(configFilePath);
+    configOptions = loadedConfig.default || loadedConfig;
+  } catch (err) {
+    console.warn("⚠️  Failed to load options from config file.");
+  }
+} else {
+  console.warn("⚠️  Config file not found, skipping...");
+}
+
+// Tags
+const tags = argv.tags || process.env.TAGS || configOptions.tags;
+if (tags) {
+  cucumberArgs.push("--tags", tags);
+}
+
+// Feature file(s)
+const feature = argv.feature || process.env.FEATURE_PATH;
+if (feature) {
+  cucumberArgs.push(path.resolve(process.cwd(), feature));
+} else if (configOptions.paths && configOptions.paths.length > 0) {
+  cucumberArgs.push(...configOptions.paths);
+}
+
+// Reporting
+const reportsDir = path.join(process.cwd(), "reports");
+const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+
+const shouldGenerateReports = argv.reporter || configOptions.reporter || false;
+
+const shouldOverwrite =
+  argv.overwrite ||
+  process.env.K6_CUCUMBER_OVERWRITE === "true" ||
+  configOptions.overwrite === true;
+
+// Build base names from feature file(s)
+let baseNames = [];
+
+if (feature) {
+  baseNames = [path.basename(feature, path.extname(feature))];
+} else if (configOptions.paths && configOptions.paths.length > 0) {
+  baseNames = configOptions.paths.map((p) => path.basename(p, path.extname(p)));
+} else {
+  baseNames = ["load-results"];
+}
+
+// Generate report paths
+const reportPaths = baseNames.map((base) => {
+  const jsonName = shouldOverwrite
+    ? `${base}.json`
+    : `${base}-${timestamp}.json`;
+  const htmlName = shouldOverwrite
+    ? `${base}.html`
+    : `${base}-${timestamp}.html`;
+
+  return {
+    json: path.join(reportsDir, jsonName),
+    html: path.join(reportsDir, htmlName),
+  };
+});
+
+// Inject report formats into cucumber arguments
+if (shouldGenerateReports) {
+  fs.mkdirSync(reportsDir, { recursive: true });
+
+  cucumberArgs.push("--format", "summary");
+
+  reportPaths.forEach(({ json, html }) => {
+    cucumberArgs.push("--format", `json:${json}`);
+    cucumberArgs.push("--format", `html:${html}`);
+  });
+}
+
+console.log("📝 Reporter Enabled:", shouldGenerateReports);
+console.log("📝 Overwrite Enabled:", shouldOverwrite);
+
+console.log("\n▶️ Final arguments passed to cucumber-js:");
+console.log(["npx", ...cucumberArgs].join(" ") + "\n");
+
+const cucumberProcess = spawn("npx", cucumberArgs, {
+  stdio: "inherit",
+  env: {
+    ...process.env,
+    K6_CUCUMBER_OVERWRITE: shouldOverwrite ? "true" : "false",
+    TAGS: tags,
+    FEATURE_PATH: feature,
+    REPORT_JSON_PATH: reportPaths[0]?.json,
+    REPORT_HTML_PATH: reportPaths[0]?.html,
+  },
+});
+
+cucumberProcess.on("close", (code) => {
+  console.log(`\n-----------------------------------------`);
+  if (code === 0) {
+    console.log("✅ k6-cucumber-steps execution completed successfully.");
+  } else {
+    console.error("❌ k6-cucumber-steps execution failed.");
+  }
+  console.log(`-----------------------------------------\n`);
+  process.exit(code);
+});

package/cucumber.js

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

package/index.js

@@ -1 +1,23 @@
-export * from "./step_definitions/load_test_steps.js";
+// Import necessary modules
+const buildK6Script = require("./libs/helpers/buildK6Script");
+const generateHeaders = require("./libs/helpers/generateHeaders");
+const resolveBody = require("./libs/helpers/resolveBody");
+const {
+  generateK6Script: generateTempK6Script,
+  runK6Script,
+} = require("./libs/utils/k6Runner");
+
+// Export the main functionalities of the package
+module.exports = {
+  // Helper functions
+  buildK6Script,
+  generateHeaders,
+  resolveBody,
+
+  // k6 script generation and execution utilities
+  generateK6Script: generateTempK6Script,
+  runK6Script,
+
+  // Step definitions (optional, if users need direct access)
+  stepDefinitions: require("./step_definitions/load_test_steps"),
+};

package/package.json

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

package/step_definitions/load_test_steps.js

@@ -174,23 +174,19 @@ Then(
       );
     }
     try {
-      // Generate the k6 script content
       const scriptContent = buildK6Script(this.config);
-
-      // Generate the temporary k6 script file with overwrite option
       const scriptPath = await generateK6Script(
         scriptContent,
         "load",
-        this.overwrite
+        process.env.K6_CUCUMBER_OVERWRITE === "true"
+      );
+      const stdout = await runK6Script(
+        scriptPath,
+        process.env.K6_CUCUMBER_OVERWRITE === "true"
       );
-
-      // 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/bin/k6-cucumber-runner.js

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-
-console.log("-----------------------------------------");
-console.log("🚀 Starting k6-cucumber-steps execution...");
-console.log("-----------------------------------------");
-
-const path = require("path");
-const { spawn } = require("child_process");
-require("dotenv").config();
-const argv = require("yargs")
-  .usage("Usage: $0 run [options]")
-  .option("feature", {
-    alias: "f",
-    describe: "Path to the feature file",
-    type: "string",
-  })
-  .option("tags", {
-    alias: "t",
-    describe: "Cucumber tags to filter scenarios (e.g., @smoke)",
-    type: "string",
-  })
-  .option("reporter", {
-    alias: "r",
-    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",
-  "--require-module",
-  "@babel/register",
-  "--require",
-  path.resolve(
-    process.cwd(),
-    "node_modules",
-    "k6-cucumber-steps",
-    "step_definitions"
-  ),
-  "--require",
-  path.resolve(process.cwd(), "step_definitions"), // Include user's local step definitions
-  "--format",
-  "summary",
-  "--format",
-  "progress", // Progress bar format
-];
-
-// 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:${path.join(reportsDir, "load-results.json")}`,
-    "--format",
-    `html:${path.join(reportsDir, "load-results.html")}`
-  );
-}
-
-/**
- * Main function to execute the Cucumber process.
- */
-async function main() {
-  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) => {
-      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));