k6-cucumber-steps 1.0.16 → 1.0.18

package/.vscode/extensions.json

@@ -1,5 +1,6 @@
 {
-    "recommendations": [
-        "cucumberopen.cucumber-official"
-    ]
-}
+  "recommendations": [
+    "cucumberopen.cucumber-official",
+    "alexkrechik.cucumberautocomplete"
+  ]
+}

package/.vscode/settings.json

@@ -5,6 +5,8 @@
     "src/features/**/*.k6.feature",
     "src/features/template/*.feature"
   ],
-  "cucumber.glue": ["step_definitions/*.js","src/features/stepDefinitions/*.js"
-]
+  "cucumber.glue": [
+    "step_definitions/*.js",
+    "src/features/stepDefinitions/*.js"
+  ]
 }

package/README.md

@@ -33,39 +33,122 @@ Run [k6](https://k6.io/) performance/load tests using [Cucumber](https://cucumbe
 npm install k6-cucumber-steps
 ```
 
----
-
 ## 🚀 Usage
 
 ### CLI
 
 ```bash
-npx k6-cucumber-steps run --feature ./features/example.feature
+npx k6-cucumber-steps run [options]
+```
+
+#### Options
+
+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.
+
+### Example Usage with Options
+
+```bash
+npx k6-cucumber-steps run --feature ./features/my_feature.feature --tags "@load and not @wip" --reporter
 ```
 
-### Programmatic
+---
+
+## 🛠️ Getting Started
+
+Here's a step-by-step guide to using `k6-cucumber-steps` in your project:
+
+**Prerequisites:**
+
+1.  **Node.js and npm (or yarn):** Ensure you have Node.js and npm (or yarn) installed.
+2.  **k6:** Install k6 on your system following the instructions at [k6.io/docs/getting-started/installation/](https://www.google.com/search?q=https://k6.io/docs/getting-started/installation/).
+3.  **@cucumber/cucumber:** This package is required for using Cucumber.
+4.  **cucumber-html-reporter:** This package is needed if you intend to generate detailed HTML reports
+
+**Setup:**
+
+1.  **Create a new project:**
 
-```ts
-import { runK6Feature } from "k6-cucumber-steps";
+    ```bash
+    mkdir my-performance-test
+    cd my-performance-test
+    npm init -y
+    # or
+    yarn init -y
+    ```
 
-await runK6Feature("./features/example.feature");
+2.  **Install dependencies:**
+
+    ```bash
+    npm install --save-dev @cucumber/cucumber k6 dotenv k6-cucumber-steps cucumber-html-reporter
+    # or
+    yarn add --dev @cucumber/cucumber k6 dotenv k6-cucumber-steps cucumber-html-reporter
+    ```
+
+3.  **Create `.env` file (optional):** Create a `.env` file in your project root for environment variables as described in the "Environment Variables" section below.
+
+4.  **Create `features` directory and feature files:**
+
+    ```bash
+    mkdir features
+    # Create your .feature files inside the features directory (e.g., example.feature)
+    ```
+
+5.  **Configure `cucumber.js`:**
+    Create a `cucumber.js` file at the root of your project with the following content:
+
+    ```javascript
+    // cucumber.js
+    require("dotenv").config();
+
+    module.exports = {
+      requireModule: ["@babel/register"], // If your features or local steps need transpilation
+      require: [
+        "./node_modules/k6-cucumber-steps/step_definitions/**/*.js", // Path to k6-cucumber-steps' step definitions
+        // You can add paths to your local step definitions here if needed
+      ],
+      format: [
+        "summary",
+        "json:reports/load-report.json", // For JSON report
+        "html:reports/report.html", // For HTML report (requires @cucumber/html-formatter)
+      ],
+      tags: process.env.TAGS,
+    };
+    ```
+
+**Running Tests:**
+
+From the root of your project, use the CLI command:
+
+```bash
+npx k6-cucumber-steps run
+```
+
+You can also specify a feature file or tags:
+
+```bash
+npx k6-cucumber-steps run --feature features/example.feature -t "@yourTag"
 ```
 
 ---
 
-## Setup
+## Setup (Detailed)
 
-1. **Environment Variables**: Create a `.env` file in your project root based on the provided `.env.example`:
+1.  **Environment Variables**: Create a `.env` file in your project root based on the provided `.env.example`:
 
-   ```env
-   BASE_URL=https://api.example.com
-   API_KEY=your_api_key
-   BEARER_TOKEN=your_bearer_token
-   BASIC_USER=your_basic_user
-   BASIC_PASS=your_basic_pass
-   ```
+    ```env
+    BASE_URL=[https://api.example.com](https://api.example.com)
+    API_KEY=your_api_key
+    BEARER_TOKEN=your_bearer_token
+    BASIC_USER=your_basic_user
+    BASIC_PASS=your_basic_pass
+    TAGS=@yourTag
+    ```
 
-2. **Feature Files**: Write your feature files using the provided step definitions.
+2.  **Feature Files**: Write your feature files using the provided step definitions.
 
 ## Gherkin Examples
 
@@ -77,17 +160,17 @@ Here’s how you can write a feature file using the provided step definitions:
 Feature: API Performance Testing
 
   Scenario: Run load tests with dynamic GET requests
-    Given I have a k6 script for GET testing
-    When I run the k6 script with the following configurations:
+    Given I set a k6 script for GET testing
+    When I set to run the k6 script with the following configurations:
       | virtual_users | duration | http_req_failed | http_req_duration |
       | 50            | 10       | rate<0.05       | p(95)<3000        |
-    And the following endpoint(s) is/are used:
+    And I set the following endpoint(s) used:
       """
       /api/profile
-      https://reqres.in/api/users?page=2
+      [https://reqres.in/api/users?page=2](https://reqres.in/api/users?page=2)
       """
     And when the authentication type is "none"
-    Then the API should handle the GET request successfully
+    Then I see the API should handle the GET request successfully
 ```
 
 ### Example 2: Test POST Endpoint with Bearer Token Authentication
@@ -96,23 +179,23 @@ Feature: API Performance Testing
 Feature: API Performance Testing
 
   Scenario: Run load tests with dynamic POST requests
-    Given I have a k6 script for POST testing
-    When I run the k6 script with the following configurations:
+    Given I set a k6 script for POST testing
+    When I set to run the k6 script with the following configurations:
       | virtual_users | duration | http_req_failed | http_req_duration |
       | 20            | 60       | rate<0.01       | p(95)<300         |
     And the authentication type is "bearer_token"
-    And the following endpoint(s) is/are used:
+    And I set the following endpoint(s) used:
       """
       /api/v1/users
       """
-    And the following POST body is used for "/api/v1/users"
+    And I set the following POST body is used for "/api/v1/users"
       """
       {
         "username": "{{username}}",
         "email": "{{faker.internet.email}}"
       }
       """
-    Then the API should handle the POST request successfully
+    Then I see the API should handle the POST request successfully
 ```
 
 ## Step Definitions
@@ -120,33 +203,33 @@ Feature: API Performance Testing
 ### Authentication Steps
 
 ```gherkin
-When the authentication type is "api_key"
-When the authentication type is "bearer_token"
-When the authentication type is "basic"
-When the authentication type is "none"
+When I set the authentication type is "api_key"
+When I set the authentication type is "bearer_token"
+When I set the authentication type is "basic"
+When I set the authentication type is "none"
 ```
 
 ### Request Configuration Steps
 
 ```gherkin
-Given I have a k6 script for {word} testing
-When I run the k6 script with the following configurations:
-When the request headers are:
-When the following endpoint(s) is/are used:
-When the following {word} body is used for {string}
+Given I set a k6 script for {word} testing
+When I set to run the k6 script with the following configurations:
+When I set the request headers:
+When I set the following endpoint(s) used:
+When I set the following {word} body is used for {string}
 ```
 
 ### Assertion Steps
 
 ```gherkin
-Then the API should handle the {word} request successfully
+Then I see the API should handle the {word} request successfully
 ```
 
 ## Test Results
 
 Below is an example of the Cucumber report generated after running the tests:
-
-![Cucumber Report](./assets/k6-cucumber-report.png)
+<img src="assets/k6-cucumber-report.png" alt="Cucumber report generated after running the tests" width="60%" />
+<img src="assets/k6-cucumber-report2.png" alt="Cucumber report generated after running the tests" width="60%" />
 
 ### Explanation of the Report
 

package/index.js

@@ -1,6 +1 @@
-// Export all exports from your helper files
-export * from "./lib/helpers/buildK6Script";
-export * from "./lib/helpers/generateHeaders";
-export * from "./lib/helpers/resolveBody";
-export * from "./lib/utils/k6Runner";
 export * from "./step_definitions/load_test_steps.js";

package/package.json

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

package/step_definitions/load_test_steps.d.ts

@@ -36,35 +36,35 @@ export function Then(
 ): void;
 
 declare function Given(
-  pattern: "I have a k6 script for {word} testing",
+  pattern: "I set a k6 script for {word} testing",
   implementation: (
     this: import("@cucumber/cucumber").World,
     method: string
   ) => void
 ): void;
 declare function When(
-  pattern: "I run the k6 script with the following configurations:",
+  pattern: "I set to run the k6 script with the following configurations:",
   implementation: (
     this: import("@cucumber/cucumber").World,
     dataTable: DataTable
   ) => void
 ): void;
 declare function When(
-  pattern: "the request headers are:",
+  pattern: "I set the request headers:",
   implementation: (
     this: import("@cucumber/cucumber").World,
     dataTable: DataTable
   ) => void
 ): void;
 declare function When(
-  pattern: "the following endpoint\\(s) is\\/are used:",
+  pattern: "I set the following endpoint\\(s) used:",
   implementation: (
     this: import("@cucumber/cucumber").World,
     docString: string
   ) => void
 ): void;
 declare function When(
-  pattern: "the following {word} body is used for {string}",
+  pattern: "I set the following {word} body is used for {string}",
   implementation: (
     this: import("@cucumber/cucumber").World,
     method: string,
@@ -73,14 +73,14 @@ declare function When(
   ) => void
 ): void;
 declare function When(
-  pattern: "the authentication type is {string}",
+  pattern: "I set the authentication type is {string}",
   implementation: (
     this: import("@cucumber/cucumber").World,
     authType: string
   ) => void
 ): void;
 declare function Then(
-  pattern: "the API should handle the {word} request successfully",
+  pattern: "I see the API should handle the {word} request successfully",
   implementation: (
     this: import("@cucumber/cucumber").World,
     method: string,

package/step_definitions/load_test_steps.js

@@ -18,12 +18,12 @@ const validateThreshold = (threshold) => {
   }
 };
 
-Given("I have a k6 script for {word} testing", function (method) {
+Given("I set a k6 script for {word} testing", function (method) {
   this.config = { method: method.toUpperCase() };
 });
 
 When(
-  "I run the k6 script with the following configurations:",
+  "I set to run the k6 script with the following configurations:",
   function (dataTable) {
     const row = dataTable.hashes()[0];
 
@@ -68,7 +68,7 @@ When(
     }
   }
 );
-When("the request headers are:", function (dataTable) {
+When("I set the request headers:", function (dataTable) {
   const headers = {};
   dataTable.hashes().forEach(({ Header, Value }) => {
     headers[Header] = Value;
@@ -80,7 +80,7 @@ When("the request headers are:", function (dataTable) {
   };
 });
 
-When("the following endpoint\\(s) is\\/are used:", function (docString) {
+When("I set the following endpoint\\(s) used:", function (docString) {
   this.config.endpoints = docString
     .trim()
     .split("\n")
@@ -88,7 +88,7 @@ When("the following endpoint\\(s) is\\/are used:", function (docString) {
 });
 
 When(
-  "the following {word} body is used for {string}",
+  "I set the following {word} body is used for {string}",
   function (method, endpoint, docString) {
     this.config.method = method.toUpperCase();
     this.config.body = resolveBody(docString, process.env);
@@ -96,12 +96,12 @@ When(
   }
 );
 
-When("the authentication type is {string}", function (authType) {
+When("I set the authentication type is {string}", function (authType) {
   this.config.headers = generateHeaders(authType, process.env);
 });
 
 Then(
-  "the API should handle the {word} request successfully",
+  "I see the API should handle the {word} request successfully",
   { timeout: 60000 },
   async function (method) {
     if (!this.config || !this.config.method) {