Intermediate

// File: pages/LoginPage.ts
// => File: pages/LoginPage.ts
// => State: context updated
export class LoginPage {
  // => Class: Encapsulates login page UI
  // => State: context updated
  private usernameInput = 'input[name="username"]';
  // => Locator: CSS selector for username field
  // => State: context updated
  private passwordInput = 'input[name="password"]';
  // => Locator: Password field selector
  // => State: context updated
  private submitButton = 'button[type="submit"]';
  // => Locator: Submit button selector
  // => State: context updated
  private errorMessage = ".error-message";
  // => Locator: Error display element
 
  constructor(private page: any) {
    // => Constructor: Receives Playwright/Selenium page object
    // => Dependency injection: Page driver from test framework
  }
  // => End: block
 
  async enterUsername(username: string): Promise<void> {
    // => Method: Encapsulates username entry
    await this.page.fill(this.usernameInput, username);
    // => Action: Fill username field
    // => Hides: Implementation detail of how to enter text
  }
  // => End: block
 
  async enterPassword(password: string): Promise<void> {
    // => Method: Encapsulates password entry
    await this.page.fill(this.passwordInput, password);
    // => Action: Fill password field
  }
  // => End: block
 
  async clickSubmit(): Promise<void> {
    // => Method: Encapsulates button click
    await this.page.click(this.submitButton);
    // => Action: Click submit button
    // => Waits: Playwright auto-waits for element
  }
  // => End: block
 
  async getErrorMessage(): Promise<string> {
    // => Method: Retrieves error text
    return await this.page.textContent(this.errorMessage);
    // => Return: Error message text
    // => Output: "Invalid credentials" or similar
  }
  // => End: block
 
  async login(username: string, password: string): Promise<void> {
    // => Method: Combines multiple actions
    await this.enterUsername(username);
    // => Step 1: Enter username
    await this.enterPassword(password);
    // => Step 2: Enter password
    await this.clickSubmit();
    // => Step 3: Submit form
    // => Convenience: Single method for common workflow
  }
  // => End: block
}
// => End: block

// File: step-definitions/login.steps.ts  // => File: step-definitions/login.steps.ts
import { Given, When, Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
import { LoginPage } from "../pages/LoginPage";
// => Import: LoginPage module
 
When("I log in with username {string} and password {string}", async function (username: string, password: string) {
  // => When: Uses Page Object instead of direct driver calls
  const loginPage = new LoginPage(this.page);
  // => Create: Page Object instance with driver
  await loginPage.login(username, password);
  // => Action: High-level login method
  // => Benefits: No locators in step definition
  // => Maintainability: Locator changes only affect LoginPage
});
// => End: function/callback
 
Then("I should see login error {string}", async function (expectedError: string) {
  // => Then: Verify error using Page Object
  const loginPage = new LoginPage(this.page);
  // => Var: loginPage = new LoginPage(this.page);
  const actualError = await loginPage.getErrorMessage();
  // => Query: Get error via Page Object method
  expect(actualError).to.equal(expectedError);
  // => Assertion: Error matches expectation
});
// => End: function/callback

Scenario: Login with invalid password
  # => Scenario: Single test case for Login with invalid password
  Given I am on the login page
    # => Given: Establishes precondition
  When I log in with username "alice@example.com" and password "wrongpass"
    # => When: Performs action
  Then I should see login error "Invalid credentials"
    # => Then: Asserts expected outcome

// File: step-definitions/api.steps.ts  // => File: step-definitions/api.steps.ts
import { Given, When, Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
import axios, { AxiosResponse } from "axios";
// => Import: axios module
 
interface ApiWorld {
  // => Type: ApiWorld defines data structure
  baseUrl: string;
  // => Property: baseUrl value
  response?: AxiosResponse;
  // => Execute: Statement runs
  requestBody?: any;
  // => Execute: Statement runs
}
// => End: block
// => State: context updated
 
Given("the API is available at {string}", function (this: ApiWorld, baseUrl: string) {
  // => Given: Set base URL for API calls
  // => Effect: function side effects applied
  this.baseUrl = baseUrl;
  // => World: Store base URL
  // => Example: "http://localhost:3000/api"
});
// => End: function/callback
// => State: context updated
 
When("I send a GET request to {string}", async function (this: ApiWorld, endpoint: string) {
  // => When: HTTP GET request
  const url = `${this.baseUrl}${endpoint}`;
  // => URL: Combine base + endpoint
  // => Example: "http://localhost:3000/api/users"
 
  try {
    // => Try: attempt operation
    this.response = await axios.get(url);
    // => Request: Axios GET call
    // => Response: {status: 200, data: {...}, headers: {...}}
  } catch (error: any) {
    // => Execute: statement runs
    this.response = error.response;
    // => Error: Store error response for Then step
    // => Allows: Testing error scenarios (404, 500, etc.)
  }
  // => End: block
});
// => End: function/callback
 
When(
  // => Call: When()
  "I send a POST request to {string} with:",
  // => Execute: statement runs
  async function (this: ApiWorld, endpoint: string, dataTable: DataTable) {
    // => When: HTTP POST with body
    const url = `${this.baseUrl}${endpoint}`;
    // => Var: url = `${this.baseUrl}${endpoint}`;
    this.requestBody = dataTable.rowsHash();
    // => Body: Convert table to JSON object
    // => Example: {username: "alice", email: "alice@example.com"}
 
    try {
      // => Try: attempt operation
      this.response = await axios.post(url, this.requestBody);
      // => Request: POST with JSON body
      // => Response: {status: 201, data: {id: 1, ...}}
    } catch (error: any) {
      // => Execute: statement runs
      this.response = error.response;
      // => Error: Capture for error scenarios
    }
    // => End: block
  },
  // => End: Object property
);
 
Then("the response status should be {int}", function (this: ApiWorld, expectedStatus: number) {
  // => Then: Verify HTTP status code
  expect(this.response).to.exist;
  // => Assertion: Response received
  expect(this.response!.status).to.equal(expectedStatus);
  // => Assertion: Status matches
  // => Output: Test passes (e.g., 200, 201, 404)
});
// => End: function/callback
 
Then(
  // => Call: Then()
  "the response should have {string} equal to {string}",
  // => Execute: statement runs
  function (this: ApiWorld, fieldPath: string, expectedValue: string) {
    // => Then: Verify response field
    const actualValue = this.response!.data[fieldPath];
    // => Extract: Field from response body
    // => Example: response.data.username
    expect(actualValue).to.equal(expectedValue);
    // => Assertion: Field value matches
  },
  // => End: Object property
);
 
Then("the response should contain {int} items", function (this: ApiWorld, expectedCount: number) {
  // => Then: Verify array length
  expect(this.response!.data).to.be.an("array");
  // => Assertion: Response is array
  expect(this.response!.data).to.have.length(expectedCount);
  // => Assertion: Array size matches
  // => Output: Test passes (e.g., 5 users returned)
});
// => End: function/callback

Feature: User API
  # => Feature: Groups related scenarios for User API
 
  Scenario: Get all users
    # => Scenario: Single test case for Get all users
    Given the API is available at "http://localhost:3000/api"
      # => Given: Establishes precondition
    When I send a GET request to "/users"
      # => When: Performs action
    Then the response status should be 200
      # => Then: Asserts expected outcome
    And the response should contain 3 items
      # => And: Continues previous step type
 
  Scenario: Create new user
    # => Scenario: Single test case for Create new user
    Given the API is available at "http://localhost:3000/api"
      # => Given: Establishes precondition
    When I send a POST request to "/users" with:
      # => When: Performs action
      | username | alice            |
        # => Table: Column headers username | alice
      | email    | alice@example.com|
        # => Table: Column headers email | alice@example.com
    Then the response status should be 201
      # => Then: Asserts expected outcome
    And the response should have "username" equal to "alice"
      # => And: Continues previous step type
 
  Scenario: Get non-existent user
    # => Scenario: Single test case for Get non-existent user
    Given the API is available at "http://localhost:3000/api"
      # => Given: Establishes precondition
    When I send a GET request to "/users/999"
      # => When: Performs action
    Then the response status should be 404
      # => Then: Asserts expected outcome

// File: step-definitions/database.steps.ts  // => File: step-definitions/database.steps.ts
import { Given, When, Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
import { Pool } from "pg"; // PostgreSQL client
// => Import: pg module
 
interface DbWorld {
  // => Type: DbWorld defines data structure
  dbPool: Pool;
  // => Property: dbPool value
  queryResult?: any[];
  // => Execute: Statement runs
}
// => End: block
// => State: modified in current scope
 
Given("the database is empty", async function (this: DbWorld) {
  // => Given: Clear database for clean state
  // => Closure: captures outer scope
  this.dbPool = new Pool({
    // => Set: this.dbPool on World object
    host: "localhost",
    // => Execute: Statement runs
    database: "test_db",
    // => Execute: Statement runs
    user: "test_user",
    // => Execute: Statement runs
    password: "test_pass",
    // => Execute: statement runs
    // => State: modified in current scope
  });
  // => Connection: Test database pool
  // => State: modified in current scope
 
  await this.dbPool.query("DELETE FROM users");
  // => Cleanup: Remove all users
  // => Async: resolves when operation completes
  await this.dbPool.query("DELETE FROM orders");
  // => Cleanup: Remove all orders
  // => Output: Empty tables for scenario
});
// => End: function/callback
// => State: modified in current scope
 
Given("the following users exist in the database:", async function (this: DbWorld, dataTable: DataTable) {
  // => Given: Seed database with test data
  // => Closure: captures outer scope
  const users = dataTable.hashes();
  // => Parse: Table to array of user objects
  // => State: modified in current scope
 
  for (const user of users) {
    // => Loop: Iterate collection
    await this.dbPool.query(
      // => Await: Async operation completes
      "INSERT INTO users (username, email, role) VALUES (substantial amounts substantial amounts substantial amounts)",
      // => Execute: Statement runs
      // => State: modified in current scope
      [user.username, user.email, user.role],
      // => Execute: statement runs
      // => State: modified in current scope
    );
    // => Insert: Add user to database
    // => Parameterized: Prevents SQL injection
  }
  // => Output: Users inserted (e.g., 3 rows)
  // => State: modified in current scope
});
// => End: function/callback
// => State: modified in current scope
 
When("a user {string} is created with email {string}", async function (this: DbWorld, username: string, email: string) {
  // => When: Trigger user creation
  await this.dbPool.query(
    // => Await: Async operation completes
    "INSERT INTO users (username, email, role) VALUES (substantial amounts substantial amounts substantial amounts)",
    // => Execute: Statement runs
    [username, email, "user"],
    // => Execute: statement runs
  );
  // => Insert: Create new user
  // => Default: Role set to 'user'
});
// => End: function/callback
 
Then("the database should contain {int} users", async function (this: DbWorld, expectedCount: number) {
  // => Then: Verify user count
  const result = await this.dbPool.query("SELECT COUNT(*) FROM users");
  // => Query: Count rows in users table
  const actualCount = parseInt(result.rows[0].count);
  // => Extract: Count from query result
  expect(actualCount).to.equal(expectedCount);
  // => Assertion: Count matches
  // => Output: Test passes (e.g., 4 users)
});
// => End: function/callback
 
Then(
  // => Call: Then()
  "user {string} should exist with email {string}",
  // => Execute: statement runs
  async function (this: DbWorld, username: string, expectedEmail: string) {
    // => Then: Verify specific user data
    const result = await this.dbPool.query("SELECT email FROM users WHERE username = substantial amounts", [username]);
    // => Query: Find user by username
 
    expect(result.rows).to.have.length(1);
    // => Assertion: User exists (1 row)
    expect(result.rows[0].email).to.equal(expectedEmail);
    // => Assertion: Email matches
    // => Output: Test passes (email correct)
  },
  // => End: Object property
);
 
Then("user {string} should have role {string}", async function (this: DbWorld, username: string, expectedRole: string) {
  // => Then: Verify user role
  const result = await this.dbPool.query("SELECT role FROM users WHERE username = substantial amounts", [username]);
  // => Query: Get user role
 
  expect(result.rows[0].role).to.equal(expectedRole);
  // => Assertion: Role matches
});
// => End: function/callback

@database
Feature: User Database Operations
  # => Feature: Groups related scenarios for User Database Operations
 
  Background:
    # => Background: Runs before each scenario in this feature
    Given the database is empty
      # => Given: Establishes precondition
 
  Scenario: Create user in database
    # => Scenario: Single test case for Create user in database
    When a user "alice" is created with email "alice@example.com"
      # => When: Performs action
    Then the database should contain 1 users
      # => Then: Asserts expected outcome
    And user "alice" should exist with email "alice@example.com"
      # => And: Continues previous step type
 
  Scenario: Seed multiple users
    # => Scenario: Single test case for Seed multiple users
    Given the following users exist in the database:
      # => Given: Establishes precondition
      | username | email              | role  |
        # => Table: Column headers username | email | role
      | alice    | alice@example.com  | admin |
        # => Table: Column headers alice | alice@example.com | admin
      | bob      | bob@example.com    | user  |
        # => Table: Column headers bob | bob@example.com | user
      | charlie  | charlie@example.com| user  |
        # => Table: Column headers charlie | charlie@example.com | user
    Then the database should contain 3 users
      # => Then: Asserts expected outcome
    And user "alice" should have role "admin"
      # => And: Continues previous step type
    And user "bob" should have role "user"
      # => And: Continues previous step type

# File: src/test/resources/features/calculator.feature
Feature: Calculator Operations
  # => Feature: Groups related scenarios for Calculator Operations
 
  Scenario: Add two numbers
    # => Scenario: Single test case for Add two numbers
    Given I have a calculator
      # => Given: Establishes precondition
    When I add 15 and 27
      # => When: Performs action
    Then the result should be 42
      # => Then: Asserts expected outcome

// File: src/test/java/steps/CalculatorSteps.java
// => File: src/test/java/steps/CalculatorSteps.java
// => State: context updated
package steps;
// => Execute: Statement runs
 
import io.cucumber.java.en.Given;
// => Import: module loaded
import io.cucumber.java.en.When;
// => Import: module loaded
import io.cucumber.java.en.Then;
// => Import: module loaded
import static org.junit.Assert.assertEquals;
// => Import: module loaded
 
public class CalculatorSteps {
    // => Class: Step definitions for calculator
// => State: context updated
    private Calculator calculator;
    // => State: Calculator instance
    // => State: context updated
    private int result;
    // => State: Calculation result
    // => State: context updated
 
    @Given("I have a calculator")
    // => Annotation: metadata marker
    // => Effect: function side effects applied
    public void i_have_a_calculator() {
        // => Given: Initialize calculator
    // => Effect: function side effects applied
        calculator = new Calculator();
        // => Instance: New calculator for scenario
    }
    // => End: block
 
    @When("I add {int} and {int}")
    // => Annotation: metadata marker
    public void i_add_and(int a, int b) {
        // => When: {int} extracts integers from step
        // => Example: "I add 15 and 27" → a=15, b=27
        result = calculator.add(a, b);
        // => Action: Call add method
        // => result: 42 (when a=15, b=27)
    }
    // => End: block
 
    @Then("the result should be {int}")
    // => Annotation: metadata marker
    public void the_result_should_be(int expected) {
        // => Then: Verify result
        assertEquals(expected, result);
        // => Assertion: JUnit assertEquals
        // => Output: Test passes (result == 42)
    }
    // => End: block
}
// => End: block

// File: src/main/java/Calculator.java
// => File: src/main/java/Calculator.java
public class Calculator {
    // => Class: Calculator implementation
 
    public int add(int a, int b) {
        // => Method: Addition operation
        return a + b;
        // => Return: Sum of inputs
        // => Output: 42 (when a=15, b=27)
    }
    // => End: block
}
// => End: block

// File: src/test/java/RunCucumberTest.java  // => File: src/test/java/RunCucumberTest.java
import org.junit.runner.RunWith;
// => Import: module loaded
import io.cucumber.junit.Cucumber;
// => Import: module loaded
import io.cucumber.junit.CucumberOptions;
// => Import: module loaded
 
@RunWith(Cucumber.class)
// => Annotation: Use Cucumber JUnit runner
@CucumberOptions(
// => Annotation: metadata marker
    features = "src/test/resources/features",
    // => Config: Feature file location
    glue = "steps",
    // => Config: Step definition package
    plugin = {"pretty", "html:target/cucumber-reports"}
    // => Config: Report formats
)
public class RunCucumberTest {
    // => Runner: Executes Cucumber tests via JUnit
    // => Output: Runs all .feature files
}
// => End: block

# File: Features/UserRegistration.feature
Feature: User Registration
  # => Feature: Groups related scenarios for User Registration
 
  Scenario: Register new user with valid data
    # => Scenario: Single test case for Register new user with valid d
    Given the registration form is open
      # => Given: Establishes precondition
    When I register with username "alice" and email "alice@example.com"
      # => When: Performs action
    Then the user should be created successfully
      # => Then: Asserts expected outcome
    And I should see confirmation message "Registration successful"
      # => And: Continues previous step type

// File: StepDefinitions/UserRegistrationSteps.cs
// => File: StepDefinitions/UserRegistrationSteps.cs
// => State: context updated
using TechTalk.SpecFlow;
// => Execute: Statement runs
using NUnit.Framework;
// => Execute: Statement runs
 
[Binding]
// => Attribute: Marks class as step definition container
// => State: context updated
public class UserRegistrationSteps
// => Class: UserRegistrationSteps defines behavior
// => State: context updated
{
    // => Class: Step definitions for registration
// => State: context updated
    private RegistrationService _registrationService;
    // => Field: Service under test
    // => State: context updated
    private RegistrationResult _result;
    // => Field: Operation result
    // => State: context updated
 
    [Given(@"the registration form is open")]
    // => Execute: Statement runs
    public void GivenTheRegistrationFormIsOpen()
    // => Field: GivenTheRegistrationFormIsOpen property
    {
        // => Given: Initialize registration service
        _registrationService = new RegistrationService();
        // => Instance: New service for scenario
    }
    // => End: block
 
    [When(@"I register with username ""(.*)"" and email ""(.*)""")]
    // => Execute: Statement runs
    public void WhenIRegisterWithUsernameAndEmail(string username, string email)
    // => Field: WhenIRegisterWithUsernameAndEmail property
    {
        // => When: Regex captures parameters
        // => Regex: ""(.*)"" extracts quoted strings
        // => Example: username="alice", email="alice@example.com"
        _result = _registrationService.Register(username, email);
        // => Action: Call registration method
        // => _result: {Success: true, Message: "Registration successful"}
    }
    // => End: block
 
    [Then(@"the user should be created successfully")]
    // => Execute: Statement runs
    public void ThenTheUserShouldBeCreatedSuccessfully()
    // => Field: ThenTheUserShouldBeCreatedSuccessfully property
    {
        // => Then: Verify success
        Assert.IsTrue(_result.Success);
        // => Assertion: NUnit assertion
        // => Output: Test passes (_result.Success == true)
    }
    // => End: block
 
    [Then(@"I should see confirmation message ""(.*)""")]
    // => Execute: Statement runs
    public void ThenIShouldSeeConfirmationMessage(string expectedMessage)
    // => Field: ThenIShouldSeeConfirmationMessage property
    {
        // => Then: Verify message
        Assert.AreEqual(expectedMessage, _result.Message);
        // => Assertion: Message matches
        // => Output: Test passes (message == "Registration successful")
    }
    // => End: block
}
// => End: block

// File: Models/RegistrationService.cs  // => File: Models/RegistrationService.cs
public class RegistrationService
// => Class: RegistrationService defines behavior
{
    // => Class: Registration business logic
 
    public RegistrationResult Register(string username, string email)
    // => Field: Register property
    {
        // => Method: User registration
        // => Basic validation  // => Note: Basic validation
        if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(email))
        // => Check: evaluates condition
        {
            // => Validation: Check required fields
            return new RegistrationResult
            // => Return: Function result
            {
            // => Step: Executes
                Success = false,
                // => Assign: Value stored
                Message = "Username and email are required"
                // => Assign: Message updated
            };
            // => Error: Return failure result
        }
        // => End: block
 
        // => Success case  // => Note: Success case
        return new RegistrationResult
        // => Return: Function result
        {
        // => Step: Executes
            Success = true,
            // => Assign: Value stored
            Message = "Registration successful"
            // => Assign: Message updated
        };
        // => Success: Return success result
        // => Output: {Success: true, Message: "Registration successful"}
    }
    // => End: block
}
// => End: block
 
public class RegistrationResult
// => Class: RegistrationResult defines behavior
{
    // => Class: Result object
    public bool Success { get; set; }
    // => Property: Operation success flag
    public string Message { get; set; }
    // => Property: User-facing message
}
// => End: block

# File: features/string_operations.feature
Feature: String Operations
  # => Feature: Groups related scenarios for String Operations
 
  Scenario: Reverse a string
    # => Scenario: Single test case for Reverse a string
    Given I have the string "hello"
      # => Given: Establishes precondition
    When I reverse the string
      # => When: Performs action
    Then the result should be "olleh"
      # => Then: Asserts expected outcome

# File: features/steps/string_steps.py
# => File: features/steps/string_steps.py
# => State: context updated
from behave import given, when, then
# => Import: Behave decorators for steps
# => State: context updated
 
@given('I have the string "{text}"')
# => Execute: statement runs
def step_given_string(context, text):
    # => Given: Store string in context
    # => context: Behave's World equivalent
    # => text: Captured from {string} parameter
    # => Example: text="hello"
    context.input_string = text
    # => Storage: Save for When step
    # => context.input_string: "hello"
 
@when('I reverse the string')
# => Execute: statement runs
def step_when_reverse(context):
    # => When: Reverse operation
    context.result = context.input_string[::-1]
    # => Action: Python slice reversal
    # => [::-1]: Reverse string
    # => context.result: "olleh"
 
@then('the result should be "{expected}"')
# => Execute: statement runs
def step_then_result(context, expected):
    # => Then: Verify result
    # => expected: Captured parameter "olleh"
    assert context.result == expected
    # => Assertion: Python assert statement
    # => Output: Test passes (result == "olleh")

Feature: User Management
  # => Feature: Groups related scenarios for User Management
 
  Scenario: Create multiple users
    # => Scenario: Single test case for Create multiple users
    Given the following users:
      # => Given: Establishes precondition
      | username | email              | age |
        # => Table: Column headers username | email | age
      | alice    | alice@example.com  | 25  |
        # => Table: Column headers alice | alice@example.com | 25
      | bob      | bob@example.com    | 30  |
        # => Table: Column headers bob | bob@example.com | 30
    When the users are saved
      # => When: Performs action
    Then the database should contain 2 users
      # => Then: Asserts expected outcome

# File: features/steps/user_steps.py  # => File: features/steps/user_steps.py
from behave import given, when, then  # => Execute: Statement runs
 
@given('the following users')
# => Execute: statement runs
def step_given_users(context):
    # => Given: Receives table from context
    context.users = []
    # => Initialize: Empty user list
 
    for row in context.table:
        # => Iteration: context.table contains rows
        # => row: Dict with columns as keys
        # => Example: {'username': 'alice', 'email': 'alice@example.com', 'age': '25'}
        user = {  # => Execute: Statement runs
            'username': row['username'],  # => Execute: Statement runs
            'email': row['email'],
            # => Execute: statement runs
            'age': int(row['age'])
            # => Convert: Age string to integer
        }
        context.users.append(user)
        # => Storage: Add to user list
    # => context.users: [{'username': 'alice', ...}, {'username': 'bob', ...}]
 
@when('the users are saved')
# => Execute: statement runs
def step_when_save(context):
    # => When: Simulate save operation
    context.saved_count = len(context.users)
    # => Storage: Count for Then step
    # => context.saved_count: 2
 
@then('the database should contain {count:d} users')
# => Execute: statement runs
def step_then_count(context, count):
    # => Then: {count:d} captures integer
    # => count: Integer parameter (2)
    assert context.saved_count == count
    # => Assertion: Count matches
    # => Output: Test passes (saved_count == 2)

Feature: Authentication Validation
  # => Feature: Groups related scenarios for Authentication Validation
 
  Scenario Outline: Login validation rules
    # => Scenario Outline: Template with Examples table
    Given a user with username "<username>" and password "<password>"
      # => Given: Establishes precondition
    When the user attempts to log in
      # => When: Performs action
    Then the login should "<outcome>"
      # => Then: Asserts expected outcome
    And the error message should be "<errorMessage>"
      # => And: Continues previous step type
 
    # Happy path cases
    Examples: Valid Credentials
      | username           | password   | outcome | errorMessage |
        # => Table: Column headers username | password | outcome
      | alice@example.com  | Secret123! | succeed |              |
        # => Row: alice@example.com, Secret123!, succeed
      | bob@example.com    | Pass456$   | succeed |              |
        # => Row: bob@example.com, Pass456$, succeed
 
    # Validation failures
    Examples: Invalid Format
      | username    | password   | outcome | errorMessage           |
        # => Table: Column headers username | password | outcome
      | invalid     | Secret123! | fail    | Invalid email format   |
        # => Table: Column headers invalid | Secret123! | fail
      | alice@      | Pass456$   | fail    | Invalid email format   |
        # => Row: alice@, Pass456$, fail
      | @example    | Secret123! | fail    | Invalid email format   |
        # => Row: @example, Secret123!, fail
 
    # Security failures
    Examples: Weak Passwords
      | username           | password | outcome | errorMessage               |
        # => Table: Column headers username | password | outcome
      | alice@example.com  | 123      | fail    | Password too short         |
        # => Row: alice@example.com, 123, fail
      | bob@example.com    | password | fail    | Password too weak          |
        # => Row: bob@example.com, password, fail
      | charlie@example.com| abc      | fail    | Password too short         |
        # => Row: charlie@example.com, abc, fail

// File: step-definitions/auth-validation.steps.ts
// => File: step-definitions/auth-validation.steps.ts
// => State: context updated
import { Given, When, Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
 
interface AuthResult {
  // => Type: AuthResult defines data structure
  success: boolean;
  // => Property: success value
  error?: string;
  // => Execute: Statement runs
}
// => End: block
// => State: context updated
 
let authResult: AuthResult;
// => Declare: authResult typed variable
 
Given("a user with username {string} and password {string}", function (username: string, password: string) {
  // => Given: Store credentials
  // => Effect: function side effects applied
  this.username = username;
  // => World: Store username
  // => State: context updated
  this.password = password;
  // => World: Store password
  // => State: context updated
});
// => End: function/callback
// => State: context updated
 
When("the user attempts to log in", function () {
  // => When: Validate and attempt login
  // => Effect: function side effects applied
  authResult = validateAndLogin(this.username, this.password);
  // => Function: Business logic validation
  // => authResult: {success: true} or {success: false, error: "..."}
});
// => End: function/callback
 
Then("the login should {string}", function (expectedOutcome: string) {
  // => Then: Verify success/fail outcome
  const shouldSucceed = expectedOutcome === "succeed";
  // => Parse: "succeed" → true, "fail" → false
  expect(authResult.success).to.equal(shouldSucceed);
  // => Assertion: Outcome matches
});
// => End: function/callback
 
Then("the error message should be {string}", function (expectedError: string) {
  // => Then: Verify error message (or absence)
  if (expectedError === "") {
    // => Case: Success (no error expected)
    expect(authResult.error).to.be.undefined;
    // => Assertion: No error present
  } else {
    // => Case: Failure (error expected)
    expect(authResult.error).to.equal(expectedError);
    // => Assertion: Error matches
  }
  // => End: block
});
// => End: function/callback
 
// => Validation logic
function validateAndLogin(username: string, password: string): AuthResult {
  // => Function: Authentication validation
 
  // => Email format validation
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  // => Regex: Basic email validation
  if (!emailRegex.test(username)) {
    // => Check: evaluates condition
    return { success: false, error: "Invalid email format" };
    // => Error: Email validation failed
  }
  // => End: block
 
  // => Password length validation  // => Note: Password length validation
  if (password.length < 8) {
    // => Check: evaluates condition
    return { success: false, error: "Password too short" };
    // => Error: Minimum length not met
  }
  // => End: block
 
  // => Password strength validation  // => Note: Password strength validation
  const hasNumber = /\d/.test(password);
  // => Var: hasNumber = /\d/.test(password);
  const hasSpecial = /[!@#$%^&*]/.test(password);
  // => Regex: Check for digits and special chars
  if (!hasNumber || !hasSpecial) {
    // => Check: evaluates condition
    return { success: false, error: "Password too weak" };
    // => Error: Complexity requirements not met
  }
  // => End: block
 
  return { success: true };
  // => Success: All validations passed
}
// => End: block

// File: support/custom-matchers.ts  // => File: support/custom-matchers.ts
import { expect } from "chai";
// => Import: chai module
 
// => Extend Chai with custom matchers  // => Note: Extend Chai with custom matchers
declare global {
  // => Execute: Statement runs
  namespace Chai {
    // => Execute: Statement runs
    interface Assertion {
      // => Type: Assertion defines data structure
      validEmail(): Assertion;
      // => Call: validEmail()
      strongPassword(): Assertion;
      // => Call: strongPassword()
      withinDateRange(start: Date, end: Date): Assertion;
      // => Call: withinDateRange()
    }
    // => End: block
    // => State: context updated
  }
  // => End: block
  // => State: context updated
}
// => End: block
// => State: context updated
 
export function setupCustomMatchers() {
  // => Setup: Register custom matchers
  // => Effect: function side effects applied
 
  // => Email validation matcher
  expect.Assertion.addMethod("validEmail", function () {
    // => Matcher: Email validation
    // => Effect: function side effects applied
    const email = this._obj as string;
    // => Input: Value being asserted
    // => State: context updated
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    // => Regex: Email pattern
    // => State: context updated
 
    this.assert(
      // => Call: this.assert()
      // => State: context updated
      emailRegex.test(email),
      // => Condition: Email matches pattern
      // => Effect: function side effects applied
      `expected #{this} to be a valid email`,
      // => Error: Assertion failed message
      // => State: context updated
      `expected #{this} to not be a valid email`,
      // => Error: Negated assertion failed
      // => State: context updated
    );
  });
  // => End: function/callback
  // => State: context updated
 
  // => Password strength matcher
  expect.Assertion.addMethod("strongPassword", function () {
    // => Matcher: Password validation
    // => Effect: function side effects applied
    const password = this._obj as string;
    // => Var: password = this._obj as string;
    const hasLength = password.length >= 8;
    // => Check: Minimum length
    const hasNumber = /\d/.test(password);
    // => Check: Contains digit
    const hasUpper = /[A-Z]/.test(password);
    // => Check: Contains uppercase
    const hasLower = /[a-z]/.test(password);
    // => Check: Contains lowercase
    const hasSpecial = /[!@#$%^&*]/.test(password);
    // => Check: Contains special char
 
    const isStrong = hasLength && hasNumber && hasUpper && hasLower && hasSpecial;
    // => Result: All criteria met
 
    this.assert(
      // => Call: this.assert()
      isStrong,
      // => Execute: Statement runs
      `expected #{this} to be a strong password (8+ chars, upper, lower, number, special)`,
      // => Execute: Statement runs
      `expected #{this} to not be a strong password`,
      // => Execute: Statement runs
    );
  });
  // => End: function/callback
 
  // => Date range matcher
  expect.Assertion.addMethod("withinDateRange", function (start: Date, end: Date) {
    // => Matcher: Date range validation
    const date = this._obj as Date;
    // => Var: date = this._obj as Date;
    const within = date >= start && date <= end;
    // => Check: Date within range
 
    this.assert(
      // => Call: this.assert()
      within,
      // => Execute: Statement runs
      `expected #{this} to be within ${start} and ${end}`,
      // => Execute: Statement runs
      `expected #{this} to not be within ${start} and ${end}`,
      // => Execute: Statement runs
    );
  });
  // => End: function/callback
}
// => End: block

// File: step-definitions/validation.steps.ts  // => File: step-definitions/validation.steps.ts
import { Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
import { setupCustomMatchers } from "../support/custom-matchers";
// => Import: custom-matchers module
 
// => Setup once  // => Note: Setup once
setupCustomMatchers();
// => Call: setupCustomMatchers()
 
Then("the email {string} should be valid", function (email: string) {
  // => Then: Use custom matcher
  expect(email).to.be.validEmail();
  // => Assertion: Custom validEmail matcher
  // => Readable: Domain-specific assertion
  // => Output: Test passes (email format valid)
});
// => End: function/callback
 
Then("the password {string} should be strong", function (password: string) {
  // => Then: Custom password matcher
  expect(password).to.be.strongPassword();
  // => Assertion: Validates password complexity
  // => Output: Test passes (password meets criteria)
});
// => End: function/callback
 
Then("the registration date should be within last 30 days", function () {
  // => Then: Date range validation
  const now = new Date();
  // => Var: now = new Date();
  const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
  // => Calculate: 30 days ago
 
  expect(this.user.registrationDate).to.be.withinDateRange(thirtyDaysAgo, now);
  // => Assertion: Custom date range matcher
  // => Output: Test passes (date within range)
});
// => End: function/callback

Scenario: Validate user registration data
  # => Scenario: Single test case for Validate user registration dat
  Given a user registered with email "alice@example.com" and password "Secure123!"
    # => Given: Establishes precondition
  Then the email "alice@example.com" should be valid
    # => Then: Asserts expected outcome
  And the password "Secure123!" should be strong
    # => And: Continues previous step type
  And the registration date should be within last 30 days
    # => And: Continues previous step type

// File: step-definitions/payment.steps.ts  // => File: step-definitions/payment.steps.ts
import { Given, When, Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
import sinon from "sinon";
// => Import: sinon module
import { PaymentService } from "../services/PaymentService";
// => Import: PaymentService module
import { StripeClient } from "../external/StripeClient";
// => Import: StripeClient module
 
interface PaymentWorld {
  // => Type: PaymentWorld defines data structure
  paymentService: PaymentService;
  // => Property: paymentService value
  stripeStub: sinon.SinonStubbedInstance<StripeClient>;
  // => Property: stripeStub value
  paymentResult?: any;
  // => Execute: Statement runs
}
// => End: block
// => State: context updated
 
Given("the payment gateway is available", function (this: PaymentWorld) {
  // => Given: Setup mock payment gateway
  // => Effect: function side effects applied
  this.stripeStub = sinon.createStubInstance(StripeClient);
  // => Stub: Create fake Stripe client
  // => Benefits: No real Stripe API calls
  // => Fast: No network I/O
 
  this.paymentService = new PaymentService(this.stripeStub);
  // => Injection: Inject stub into service
  // => Service: Uses stub instead of real Stripe
});
// => End: function/callback
// => State: context updated
 
Given("the payment gateway returns success for valid cards", function (this: PaymentWorld) {
  // => Given: Configure stub behavior
  // => Effect: function side effects applied
  this.stripeStub.charge.resolves({
    // => Execute: Statement runs
    id: "ch_test_123",
    // => Execute: Statement runs
    status: "succeeded",
    // => Execute: Statement runs
    amount: 5000,
    // => Execute: statement runs
    // => State: context updated
  });
  // => Stub: Return success response
  // => resolves: Simulates successful async call
  // => Output: Controlled test data
});
// => End: function/callback
// => State: context updated
 
Given("the payment gateway returns error for declined cards", function (this: PaymentWorld) {
  // => Given: Configure error behavior
  // => Effect: function side effects applied
  this.stripeStub.charge.rejects(new Error("Card declined"));
  // => Stub: Simulate payment failure
  // => rejects: Simulates async error
});
// => End: function/callback
 
When(
  // => Call: When()
  "I process a payment of ${int} with card {string}",
  // => Execute: statement runs
  async function (this: PaymentWorld, amount: number, cardNumber: string) {
    // => When: Trigger payment
    try {
      // => Try: attempt operation
      this.paymentResult = await this.paymentService.processPayment(amount, cardNumber);
      // => Call: Service method (uses stub internally)
      // => Result: Success or error based on stub config
    } catch (error) {
      // => Execute: statement runs
      this.paymentResult = { error: (error as Error).message };
      // => Error: Capture for Then step
    }
    // => End: block
  },
  // => End: Object property
);
 
Then("the payment should succeed", function (this: PaymentWorld) {
  // => Then: Verify success
  expect(this.paymentResult.status).to.equal("succeeded");
  // => Assertion: Payment processed
  // => Output: Test passes (stub returned success)
});
// => End: function/callback
 
Then("the payment should fail with {string}", function (this: PaymentWorld, expectedError: string) {
  // => Then: Verify error
  expect(this.paymentResult.error).to.include(expectedError);
  // => Assertion: Error message matches
  // => Output: Test passes (stub returned error)
});
// => End: function/callback
 
Then(
  // => Call: Then()
  "the payment gateway should have been called with amount ${int}",
  // => Execute: statement runs
  function (this: PaymentWorld, expectedAmount: number) {
    // => Then: Verify mock interaction
    expect(this.stripeStub.charge.calledOnce).to.be.true;
    // => Spy: Verify method called once
    const callArgs = this.stripeStub.charge.getCall(0).args;
    // => Spy: Get call arguments
    expect(callArgs[0].amount).to.equal(expectedAmount);
    // => Assertion: Called with correct amount
    // => Output: Test passes (interaction verified)
  },
  // => End: Object property
);

Feature: Payment Processing
  # => Feature: Groups related scenarios for Payment Processing
 
  Scenario: Successful payment with valid card
    # => Scenario: Single test case for Successful payment with valid
    Given the payment gateway is available
      # => Given: Establishes precondition
    And the payment gateway returns success for valid cards
      # => And: Continues previous step type
    When I process a payment of substantial amounts with card "4111111111111111"
      # => When: Performs action
    Then the payment should succeed
      # => Then: Asserts expected outcome
    And the payment gateway should have been called with amount substantial amounts
      # => And: Continues previous step type
 
  Scenario: Failed payment with declined card
    # => Scenario: Single test case for Failed payment with declined c
    Given the payment gateway is available
      # => Given: Establishes precondition
    And the payment gateway returns error for declined cards
      # => And: Continues previous step type
    When I process a payment of substantial amounts with card "4000000000000002"
      # => When: Performs action
    Then the payment should fail with "Card declined"
      # => Then: Asserts expected outcome

# File: .github/workflows/bdd-tests.yml
name: BDD Tests
# => Config: name: BDD Tests
 
on:
# => Config: on:
  push:
  # => Config: push:
    branches: [main, develop]
    # => Trigger: Run on push to main/develop
  pull_request:
  # => Config: pull_request:
    branches: [main]
    # => Trigger: Run on pull requests to main
 
jobs:
# => Config: jobs:
  bdd-smoke:
    # => Job: Fast smoke tests
    runs-on: ubuntu-latest
    # => Runner: Latest Ubuntu
 
    steps:
    # => Config: steps:
      - uses: actions/checkout@v3
        # => Step: Clone repository
 
      - uses: actions/setup-node@v3
      # => Item: uses: actions/setup-node@v3
        with:
        # => Config: with:
          node-version: "18"
          # => Step: Install Node.js 18
 
      - name: Install dependencies
      # => Item: name: Install dependencies
        run: npm ci
        # => Step: Install packages (faster than npm install)
 
      - name: Run smoke tests
      # => Item: name: Run smoke tests
        run: npx cucumber-js --tags "@smoke" --format json:reports/smoke.json
        # => Step: Run @smoke scenarios only
        # => Output: JSON report
        # => Duration: ~2 minutes
 
      - name: Upload smoke results
      # => Item: name: Upload smoke results
        uses: actions/upload-artifact@v3
        # => Config: uses: actions/upload-artifact@v
        if: always()
        # => Step: Upload results even on failure
        with:
        # => Config: with:
          name: smoke-test-results
          # => Config: name: smoke-test-results
          path: reports/smoke.json
          # => Artifact: Test results for analysis
 
  bdd-regression:
    # => Job: Full regression suite
    runs-on: ubuntu-latest
    # => Config: runs-on: ubuntu-latest
    needs: bdd-smoke
    # => Dependency: Run only if smoke tests pass
 
    services:
    # => Services: Container definitions
      postgres:
        # => Service: Test database
        image: postgres:15
        # => Image: Docker image postgres:15
        env:
        # => Config: env:
          POSTGRES_PASSWORD: test_pass
          # => Config: POSTGRES_PASSWORD: test_pass
          POSTGRES_DB: test_db
          # => Config: POSTGRES_DB: test_db
        options: >-
        # => Config: options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        # => Health check: Wait for DB ready
 
    steps:
    # => Config: steps:
      - uses: actions/checkout@v3
      # => Item: uses: actions/checkout@v3
 
      - uses: actions/setup-node@v3
      # => Item: uses: actions/setup-node@v3
        with:
        # => Config: with:
          node-version: "18"
          # => Config: node-version: "18"
 
      - name: Install dependencies
      # => Item: name: Install dependencies
        run: npm ci
        # => Config: run: npm ci
 
      - name: Run database migrations
      # => Item: name: Run database migrations
        run: npm run db:migrate
        # => Step: Setup test database schema
 
      - name: Run regression tests
      # => Item: name: Run regression tests
        run: npx cucumber-js --tags "not @smoke and not @slow" --parallel 4
        # => Step: Run non-smoke, non-slow tests
        # => Parallel: 4 workers for speed
        # => Duration: ~10 minutes
 
      - name: Generate HTML report
      # => Item: name: Generate HTML report
        if: always()
        # => Config: if: always()
        run: npx cucumber-html-reporter --input reports/*.json --output reports/index.html
        # => Step: Generate human-readable report
 
      - name: Upload regression results
      # => Item: name: Upload regression result
        uses: actions/upload-artifact@v3
        # => Config: uses: actions/upload-artifact@v
        if: always()
        # => Config: if: always()
        with:
        # => Config: with:
          name: regression-test-results
          # => Config: name: regression-test-results
          path: reports/
          # => Artifact: All test reports
 
  bdd-e2e:
    # => Job: End-to-end tests
    runs-on: ubuntu-latest
    # => Config: runs-on: ubuntu-latest
    needs: bdd-regression
    # => Dependency: Run only if regression passes
    if: github.ref == 'refs/heads/main'
    # => Condition: Only on main branch
 
    steps:
    # => Config: steps:
      - uses: actions/checkout@v3
      # => Item: uses: actions/checkout@v3
 
      - uses: actions/setup-node@v3
      # => Item: uses: actions/setup-node@v3
        with:
        # => Config: with:
          node-version: "18"
          # => Config: node-version: "18"
 
      - name: Install dependencies
      # => Item: name: Install dependencies
        run: npm ci
        # => Config: run: npm ci
 
      - name: Run E2E tests
      # => Item: name: Run E2E tests
        run: npx cucumber-js --tags "@e2e" --retry 2
        # => Step: Run end-to-end scenarios
        # => Retry: Handle flaky browser tests
        # => Duration: ~30 minutes
 
      - name: Upload E2E results
      # => Item: name: Upload E2E results
        uses: actions/upload-artifact@v3
        # => Config: uses: actions/upload-artifact@v
        if: always()
        # => Config: if: always()
        with:
        # => Config: with:
          name: e2e-test-results
          # => Config: name: e2e-test-results
          path: reports/
          # => Config: path: reports/

// File: cucumber.js  // => File: cucumber.js
const common = {
  // => Var: common = {
  // => State: context updated
  requireModule: ["ts-node/register"],
  // => Config: TypeScript support
  // => State: context updated
  require: ["step-definitions/**/*.ts"],
  // => Config: Step definition paths
  // => State: context updated
  format: [
    // => Execute: statement runs
    "progress-bar",
    // => Format: Progress bar for CI logs
    "json:reports/cucumber-report.json",
    // => Format: JSON for programmatic analysis
    "html:reports/cucumber-report.html",
    // => Format: HTML for human review
  ],
  // => Execute: statement runs
  formatOptions: {
    // => Execute: statement runs
    snippetInterface: "async-await",
    // => Config: Generate async step snippets
  },
  // => End: Object property
};
// => Execute: Statement runs
 
module.exports = {
  // => Execute: Statement runs
  default: common,
  // => Property: default value
 
  ci: {
    // => Execute: statement runs
    ...common,
    // => Config: CI-specific settings
    parallel: 4,
    // => Parallel: 4 workers
    retry: 1,
    // => Retry: Retry failed scenarios once
    failFast: true,
    // => Fail fast: Stop on first failure
    strict: true,
    // => Strict: Treat warnings as errors
  },
  // => End: Object property
 
  smoke: {
    // => Execute: statement runs
    ...common,
    // => Config: Smoke test profile
    tags: "@smoke",
    // => Filter: Only smoke scenarios
    parallel: 2,
    // => Parallel: Fewer workers for speed
  },
  // => End: Object property
};
// => Execute: Statement runs

// File: cucumber.parallel.js  // => File: cucumber.parallel.js
module.exports = {
  // => Execute: Statement runs
  default: {
    // => Execute: statement runs
    // => State: context updated
    parallel: 4,
    // => Workers: Run 4 scenarios simultaneously
    // => Speed: ~significantly faster for CPU-bound tests
    // => Optimal: Number of CPU cores
 
    publishQuiet: true,
    // => Config: Reduce log noise in parallel mode
    // => State: context updated
 
    retry: 1,
    // => Retry: Handle transient failures
    // => State: context updated
 
    retryTagFilter: "@flaky",
    // => Filter: Only retry @flaky scenarios
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
};
// => Execute: Statement runs

// File: support/hooks.ts  // => File: support/hooks.ts
import { Before, After } from "@cucumber/cucumber";
// => Import: cucumber module
import { Pool } from "pg";
// => Import: pg module
 
Before(async function () {
  // => Before: Each worker gets isolated DB
  // => Effect: function side effects applied
  const workerId = process.env.CUCUMBER_WORKER_ID || "0";
  // => Worker ID: Cucumber assigns unique ID per worker
  // => Range: '0', '1', '2', '3' for 4 workers
 
  this.dbPool = new Pool({
    // => Set: this.dbPool on World object
    host: "localhost",
    // => Execute: statement runs
    // => State: context updated
    database: `test_db_${workerId}`,
    // => Database: Separate DB per worker
    // => Isolation: Workers don't interfere
    // => Example: test_db_0, test_db_1, test_db_2, test_db_3
    user: "test_user",
    // => Execute: Statement runs
    password: "test_pass",
    // => Execute: Statement runs
  });
  // => End: function/callback
  // => State: context updated
 
  // => Clean database for scenario  // => Note: Clean database for scenario
  await this.dbPool.query("DELETE FROM users");
  // => Await: async operation resolves
  // => Async: operation resolves to result
  await this.dbPool.query("DELETE FROM orders");
  // => Cleanup: Fresh state per scenario
  // => Async: operation resolves to result
});
// => End: function/callback
// => State: context updated
 
After(async function () {
  // => After: Close DB connection
  // => Effect: function side effects applied
  await this.dbPool.end();
  // => Cleanup: Release resources
  // => Async: operation resolves to result
});
// => End: function/callback
// => State: context updated

// File: support/server-manager.ts  // => File: support/server-manager.ts
import express from "express";
// => Import: express module
 
export async function startTestServer(): Promise<number> {
  // => Function: Start server on unique port
  // => Effect: function side effects applied
  const workerId = parseInt(process.env.CUCUMBER_WORKER_ID || "0");
  // => Declare: workerId variable
  // => Effect: function side effects applied
  const basePort = 3000;
  // => Var: basePort = 3000;
  // => State: context updated
  const port = basePort + workerId;
  // => Port: 3000 + worker ID
  // => Range: 3000, 3001, 3002, 3003 for 4 workers
  // => Isolation: No port conflicts
 
  const app = express();
  // => Declare: app variable
  app.use(express.json());
  // => Call: app.use()
 
  app.get("/health", (req, res) => {
    // => Call: app.get()
    // => Effect: function side effects applied
    res.json({ status: "ok", worker: workerId });
    // => Endpoint: Health check with worker ID
    // => Effect: function side effects applied
  });
  // => End: function/callback
 
  await new Promise<void>((resolve) => {
    // => Await: Async operation completes
    app.listen(port, () => {
      // => Call: app.listen()
      console.log(`Worker ${workerId} server on port ${port}`);
      // => Log: Server started
      resolve();
      // => Call: resolve()
    });
    // => End: function/callback
  });
  // => End: function/callback
 
  return port;
  // => Return: Port number for step definitions
}
// => End: block

// File: step-definitions/api-parallel.steps.ts  // => File: step-definitions/api-parallel.steps.ts
import { Before, Given, When } from "@cucumber/cucumber";
// => Import: cucumber module
import { startTestServer } from "../support/server-manager";
// => Import: server-manager module
 
Before(async function () {
  // => Before: Start worker-specific server
  this.serverPort = await startTestServer();
  // => Port: Unique port for this worker
  // => this.serverPort: 3000, 3001, 3002, or 3003
});
// => End: function/callback
 
Given("the API server is running", async function () {
  // => Given: Verify server health
  const response = await fetch(`http://localhost:${this.serverPort}/health`);
  // => Request: Use worker-specific port
  const data = await response.json();
  // => Response: {status: "ok", worker: 0}
  expect(data.status).to.equal("ok");
  // => Assertion: Server ready
});
// => End: function/callback
 
When("I send a GET request to {string}", async function (endpoint: string) {
  // => When: API call to worker-specific port
  const url = `http://localhost:${this.serverPort}${endpoint}`;
  // => URL: Worker-isolated endpoint
  this.response = await fetch(url);
  // => Request: No interference from other workers
});
// => End: function/callback

# Sequential execution (no parallelization)
$ npx cucumber-js
# => Command: $ npx cucumber-js
# 100 scenarios (100 passed)
# Duration: 200 seconds (3m 20s)
 
# Parallel execution (4 workers)
$ npx cucumber-js --parallel 4
# => Command: $ npx cucumber-js --parallel 4
# 100 scenarios (100 passed)
# Duration: 55 seconds (~significantly faster)
# Worker 0: 25 scenarios
# Worker 1: 25 scenarios
# Worker 2: 25 scenarios
# Worker 3: 25 scenarios

// File: fixtures/user-fixtures.ts  // => File: fixtures/user-fixtures.ts
export interface UserFixture {
  // => Execute: Statement runs
  username: string;
  // => Property: username value
  email: string;
  // => Property: email value
  password: string;
  // => Property: password value
  role: "admin" | "user" | "guest";
  // => Execute: Statement runs
}
// => End: block
// => State: context updated
 
export const UserFixtures: Record<string, UserFixture> = {
  // => Fixtures: Predefined test users
  // => State: context updated
 
  admin: {
    // => Fixture: Admin user
    // => State: context updated
    username: "admin-user",
    // => Execute: Statement runs
    email: "admin@example.com",
    // => Execute: Statement runs
    password: "Admin123!",
    // => Execute: statement runs
    // => State: context updated
    role: "admin",
    // => Use case: Testing admin-only features
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
 
  regularUser: {
    // => Fixture: Standard user
    // => State: context updated
    username: "john-doe",
    // => Execute: Statement runs
    email: "john@example.com",
    // => Execute: Statement runs
    password: "User456$",
    // => Execute: statement runs
    // => State: context updated
    role: "user",
    // => Use case: Testing user features
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
 
  guest: {
    // => Fixture: Guest user
    // => State: context updated
    username: "guest-user",
    // => Execute: Statement runs
    email: "guest@example.com",
    // => Execute: Statement runs
    password: "Guest789#",
    // => Execute: statement runs
    // => State: context updated
    role: "guest",
    // => Use case: Testing limited access
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
 
  invalidEmail: {
    // => Fixture: Invalid data for error testing
    // => State: context updated
    username: "invalid-user",
    // => Execute: Statement runs
    email: "not-an-email",
    // => Execute: Statement runs
    password: "Test123!",
    // => Execute: statement runs
    // => State: context updated
    role: "user",
    // => Use case: Testing validation errors
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
};
// => Execute: Statement runs
 
export interface OrderFixture {
  // => Execute: Statement runs
  orderId: string;
  // => Property: orderId value
  customerId: string;
  // => Property: customerId value
  items: Array<{ product: string; quantity: number; price: number }>;
  // => Property: items value
  total: number;
  // => Property: total value
  status: "pending" | "shipped" | "delivered";
  // => Execute: Statement runs
}
// => End: block
// => State: context updated
 
export const OrderFixtures: Record<string, OrderFixture> = {
  // => Fixtures: Sample orders
  // => State: context updated
 
  smallOrder: {
    // => Execute: Statement runs
    orderId: "ORD-001",
    // => Execute: Statement runs
    customerId: "CUST-123",
    // => Execute: Statement runs
    items: [{ product: "Widget", quantity: 2, price: 10.0 }],
    // => Execute: Statement runs
    total: 20.0,
    // => Execute: statement runs
    // => State: context updated
    status: "pending",
    // => Use case: Testing basic order processing
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
 
  largeOrder: {
    // => Execute: Statement runs
    orderId: "ORD-002",
    // => Execute: Statement runs
    customerId: "CUST-456",
    // => Execute: Statement runs
    items: [
      // => Execute: Statement runs
      { product: "Widget", quantity: 100, price: 10.0 },
      // => Execute: Statement runs
      { product: "Gadget", quantity: 50, price: 25.0 },
      // => Execute: Statement runs
    ],
    // => Execute: statement runs
    // => State: context updated
    total: 2250.0,
    // => Execute: statement runs
    // => State: context updated
    status: "pending",
    // => Use case: Testing bulk order handling
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
};
// => Execute: Statement runs

// File: step-definitions/fixture-steps.ts  // => File: step-definitions/fixture-steps.ts
import { Given, When, Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
import { UserFixtures, OrderFixtures } from "../fixtures/user-fixtures";
// => Import: user-fixtures module
// => State: context updated
 
Given("a {string} user exists", async function (fixtureName: string) {
  // => Given: Load user fixture by name
  // => Effect: function side effects applied
  const fixture = UserFixtures[fixtureName];
  // => Lookup: Get predefined user data
  // => Example: fixtureName="admin" → UserFixtures.admin
 
  if (!fixture) {
    // => Check: evaluates condition
    // => Effect: function side effects applied
    throw new Error(`Unknown user fixture: ${fixtureName}`);
    // => Error: Invalid fixture name
    // => Effect: function side effects applied
  }
  // => End: block
  // => State: context updated
 
  this.user = await createUser(fixture);
  // => Create: Insert user in database
  // => this.user: Created user object with ID
  // => Consistent: Same data every time
});
// => End: function/callback
// => State: context updated
 
Given("an {string} order exists", async function (fixtureName: string) {
  // => Given: Load order fixture
  // => Effect: function side effects applied
  const fixture = OrderFixtures[fixtureName];
  // => Lookup: Get predefined order data
  // => State: context updated
 
  if (!fixture) {
    // => Check: Conditional branch
    throw new Error(`Unknown order fixture: ${fixtureName}`);
    // => Throw: Error on invalid state
  }
  // => End: block
  // => State: context updated
 
  this.order = await createOrder(fixture);
  // => Create: Insert order in database
  // => Fixtures: Provide complex nested data easily
});
// => End: function/callback
// => State: context updated
 
// => Database helpers
async function createUser(fixture: UserFixture): Promise<any> {
  // => Function: Create user from fixture
  // => Simulated database insert  // => Note: Simulated database insert
  return {
    // => Return: Function result
    id: Math.random().toString(36),
    // => Property: id value
    ...fixture,
    // => Execute: Statement runs
    createdAt: new Date(),
    // => Execute: statement runs
    // => Effect: function side effects applied
  };
  // => Return: User with generated ID
  // => State: context updated
}
// => End: block
// => State: context updated
 
async function createOrder(fixture: OrderFixture): Promise<any> {
  // => Function: Create order from fixture
  // => Effect: function side effects applied
  return {
    // => Return: Function result
    ...fixture,
    // => Execute: Statement runs
    createdAt: new Date(),
    // => Property: createdAt value
  };
  // => Execute: Statement runs
}
// => End: block
// => State: context updated

Feature: Order Management
  # => Feature: Groups related scenarios for Order Management
 
  Scenario: Admin can view all orders
    # => Scenario: Single test case for Admin can view all orders
    Given an "admin" user exists
      # => Given: Establishes precondition
    And a "smallOrder" order exists
      # => And: Continues previous step type
    And a "largeOrder" order exists
      # => And: Continues previous step type
    When the admin views the order list
      # => When: Performs action
    Then the list should contain 2 orders
      # => Then: Asserts expected outcome
 
  Scenario: Regular user sees only own orders
    # => Scenario: Single test case for Regular user sees only own ord
    Given a "regularUser" user exists
      # => Given: Establishes precondition
    And a "smallOrder" order exists for the user
      # => And: Continues previous step type
    When the user views the order list
      # => When: Performs action
    Then the list should contain 1 orders
      # => Then: Asserts expected outcome
 
  Scenario: Cannot create order with invalid user
    # => Scenario: Single test case for Cannot create order with inval
    Given a "guest" user exists
      # => Given: Establishes precondition
    When the guest attempts to create an order
      # => When: Performs action
    Then the order creation should fail
      # => Then: Asserts expected outcome

// File: fixtures/fixture-factory.ts
// => File: fixtures/fixture-factory.ts
// => State: context updated
export class FixtureFactory {
  // => Class: Dynamic fixture generation
  // => State: context updated
 
  static createUser(overrides: Partial<UserFixture> = {}): UserFixture {
    // => Method: Generate user with defaults + overrides
    // => Effect: function side effects applied
    return {
      // => Return: provides result to caller
      // => Caller: receives returned value
      username: `user-${Date.now()}`,
      // => Default: Unique username
      // => Effect: function side effects applied
      email: `user-${Date.now()}@example.com`,
      // => Default: Unique email
      // => Effect: function side effects applied
      password: "Default123!",
      // => Default: Valid password
      role: "user",
      // => Default: Standard user role
      ...overrides,
      // => Override: Merge custom values
      // => Example: createUser({role: 'admin'}) → admin user with generated username/email
    };
    // => Execute: Statement runs
  }
  // => End: block
 
  static createOrder(overrides: Partial<OrderFixture> = {}): OrderFixture {
    // => Method: Generate order with defaults
    return {
      // => Return: Function result
      orderId: `ORD-${Date.now()}`,
      // => Execute: Statement runs
      customerId: "CUST-DEFAULT",
      // => Execute: Statement runs
      items: [],
      // => Execute: Statement runs
      total: 0,
      // => Property: total value
      status: "pending",
      // => Execute: Statement runs
      ...overrides,
      // => Execute: Statement runs
    };
    // => Execute: Statement runs
  }
  // => End: block
}
// => End: block
 
// => Usage in step definitions
Given("a random user exists", async function () {
  // => Given: Generate unique user
  const fixture = FixtureFactory.createUser();
  // => Factory: New user with unique data
  this.user = await createUser(fixture);
  // => Benefit: No hardcoded test data conflicts
});
// => End: function/callback
 
Given("an admin user named {string} exists", async function (username: string) {
  // => Given: Generate admin with specific username
  const fixture = FixtureFactory.createUser({
    // => Declare: fixture variable
    username,
    // => Execute: Statement runs
    role: "admin",
    // => Execute: statement runs
  });
  // => Factory: Override specific fields
  this.user = await createUser(fixture);
  // => Set: this.user on World object
});
// => End: function/callback

// => WRONG: Flaky test with race condition
When("I click the submit button", async function () {
  // => When: Click button immediately
  // => Effect: function side effects applied
  await this.page.click('button[type="submit"]');
  // => Problem: Button might not be enabled yet
  // => Flaky: Passes when app is fast, fails when slow
});
// => End: function/callback
// => State: context updated
 
Then("I should see success message", async function () {
  // => Then: Check for message immediately
  // => Effect: function side effects applied
  const message = await this.page.textContent(".success-message");
  // => Problem: Message might not have appeared yet
  // => Flaky: Race between assertion and DOM update
  expect(message).to.equal("Success");
  // => Assert: Verify expected condition
});
// => End: function/callback
// => State: context updated

// File: step-definitions/anti-flaky.steps.ts  // => File: step-definitions/anti-flaky.steps.ts
import { When, Then } from "@cucumber/cucumber";
// => Import: cucumber module
import { expect } from "chai";
// => Import: chai module
 
When("I click the submit button", async function () {
  // => When: Wait for button to be clickable
  // => Effect: function side effects applied
  const submitButton = this.page.locator('button[type="submit"]');
  // => Locator: Playwright locator (lazy, doesn't query immediately)
 
  await submitButton.waitFor({ state: "visible" });
  // => Wait: Button is visible
  await submitButton.waitFor({ state: "enabled" });
  // => Wait: Button is enabled (not disabled)
  // => Explicit: Wait for ready state before click
 
  await submitButton.click();
  // => Click: Now guaranteed to be clickable
  // => Reliable: No race condition
});
// => End: function/callback
 
Then("I should see success message", async function () {
  // => Then: Wait for message to appear
  const successMessage = this.page.locator(".success-message");
  // => Declare: successMessage variable
 
  await successMessage.waitFor({ state: "visible", timeout: 5000 });
  // => Wait: Up to 5 seconds for message
  // => Timeout: Fail fast if never appears
 
  const text = await successMessage.textContent();
  // => Extract: Get message text after appearing
  expect(text).to.equal("Success");
  // => Assertion: Now reliable
});
// => End: function/callback

// File: support/retry-helpers.ts
// => File: support/retry-helpers.ts
export async function retryAsync<T>(fn: () => Promise<T>, maxAttempts: number = 3, delayMs: number = 1000): Promise<T> {
  // => Function: Retry async operation
  // => maxAttempts: Number of tries
  // => delayMs: Delay between attempts
 
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    // => Loop: Iterate collection
    try {
      // => Try: attempt operation
      return await fn();
      // => Success: Return result
    } catch (error) {
      // => Execute: Statement runs
      if (attempt === maxAttempts) {
        // => Check: evaluates condition
        throw error;
        // => Final attempt: Throw error
      }
      // => End: block
 
      console.log(`Attempt ${attempt} failed, retrying in ${delayMs}ms...`);
      // => Log: Retry notification
      await new Promise((resolve) => setTimeout(resolve, delayMs));
      // => Delay: Wait before retry
    }
    // => End: block
  }
  // => End: block
 
  throw new Error("Should not reach here");
  // => Throw: Error on invalid state
}
// => End: block

When("I fetch user data from API", async function () {
  // => When: API call with retry
  this.userData = await retryAsync(
    // => Set: this.userData on World object
    async () => {
      // => Call: async()
      const response = await fetch("http://localhost:3000/api/user");
      // => Request: May fail due to network blip
      if (!response.ok) {
        // => Check: evaluates condition
        throw new Error(`HTTP ${response.status}`);
        // => Error: Trigger retry
      }
      // => End: block
      return await response.json();
      // => Success: Return data
    },
    // => End: Object property
    3,
    // => Retry: Up to 3 attempts
    500,
    // => Delay: 500ms between attempts
  );
  // => Resilient: Handles transient network issues
});
// => End: function/callback

// File: support/hooks.ts  // => File: support/hooks.ts
import { Before, After } from "@cucumber/cucumber";
// => Import: cucumber module
 
Before(async function () {
  // => Before: Clean state for scenario
  await this.dbPool.query("DELETE FROM users");
  // => Await: async operation resolves
  await this.dbPool.query("DELETE FROM orders");
  // => Cleanup: Remove all data
  // => Isolation: Scenarios don't affect each other
 
  // => Reset in-memory caches
  globalCache.clear();
  // => Cache: Clear shared state
 
  // => Reset file system
  await fs.rm("test-uploads/", { recursive: true, force: true });
  // => Files: Remove uploaded files
  await fs.mkdir("test-uploads/", { recursive: true });
  // => Files: Recreate empty directory
});
// => End: function/callback
 
After(async function () {
  // => After: Cleanup resources
  if (this.browser) {
    // => Check: evaluates condition
    await this.browser.close();
    // => Browser: Close browser instance
    // => Prevent: Resource leaks
  }
  // => End: block
 
  if (this.dbPool) {
    // => Check: evaluates condition
    await this.dbPool.end();
    // => Database: Close connections
  }
  // => End: block
});
// => End: function/callback

// => WRONG: Non-deterministic test data
Given("a user is created", async function () {
  // => Problem: Random data causes inconsistent state
  this.user = await createUser({
    // => Set: this.user on World object
    username: `user-${Math.random()}`, // <= Random!
    // => Assign: Value stored
    createdAt: new Date(), // <= Current time!
    // => Assign: createdAt: new Date(), // < updated
  });
  // => Flaky: Different data every run
  // => Hard to debug: Can't reproduce failures
});
// => End: function/callback
 
// => RIGHT: Deterministic test data
Given("a user is created", async function () {
  // => Fixed: Predictable data
  const timestamp = new Date("2026-01-31T12:00:00Z");
  // => Fixed: Same timestamp every run
 
  this.user = await createUser({
    // => Set: this.user on World object
    username: "test-user-001",
    // => Fixed: Predictable username
    createdAt: timestamp,
    // => Execute: statement runs
  });
  // => Reliable: Same data every run
  // => Debuggable: Can reproduce failures exactly
});
// => End: function/callback

// File: cucumber.js  // => File: cucumber.js
module.exports = {
  // => Execute: Statement runs
  default: {
    // => Execute: Statement runs
    format: [
      // => Execute: statement runs
      // => State: context updated
      "progress-bar",
      // => Console: Progress bar for developers
      // => State: context updated
      "json:reports/cucumber-report.json",
      // => JSON: Machine-readable results
      // => State: context updated
      "@cucumber/pretty-formatter",
      // => Console: Detailed step output
      // => State: context updated
      "html:reports/cucumber-report.html",
      // => HTML: Human-readable report
      // => State: context updated
    ],
    // => Execute: statement runs
    // => State: context updated
    formatOptions: {
      // => Options: Report configuration
      // => State: context updated
      theme: "bootstrap",
      // => Theme: Bootstrap styling
      // => State: context updated
      snippetInterface: "async-await",
      // => Execute: Statement runs
    },
    // => End: Object property
    // => State: context updated
  },
  // => End: Object property
  // => State: context updated
};
// => Execute: Statement runs

// File: scripts/generate-report.ts  // => File: scripts/generate-report.ts
import reporter from "cucumber-html-reporter";
// => Import: cucumber-html-reporter module
 
const options = {
  // => Options: HTML reporter configuration
  // => State: context updated
  theme: "bootstrap",
  // => Theme: Bootstrap 4 styling
  // => State: context updated
  jsonFile: "reports/cucumber-report.json",
  // => Input: JSON test results
  // => State: context updated
  output: "reports/cucumber-report.html",
  // => Output: HTML report path
  // => State: context updated
  reportSuiteAsScenarios: true,
  // => Config: Group scenarios by suite
  // => State: context updated
  scenarioTimestamp: true,
  // => Config: Show execution timestamp
  // => State: context updated
  launchReport: false,
  // => Config: Don't auto-open browser
  // => State: context updated
  metadata: {
    // => Metadata: Build information
    "App Version": "1.2.3",
    // => Execute: Statement runs
    "Test Environment": "Staging",
    // => Execute: Statement runs
    Browser: "Chrome 120",
    // => Execute: Statement runs
    Platform: "Ubuntu 22.04",
    // => Execute: Statement runs
    "Executed By": "CI Pipeline",
    // => Execute: Statement runs
    "Executed On": new Date().toISOString(),
    // => Execute: statement runs
  },
  // => Displayed: Metadata in report header
  brandTitle: "E-Commerce Platform - BDD Test Results",
  // => Title: Custom report branding
};
// => Execute: Statement runs
 
reporter.generate(options);
// => Generate: Create HTML report
console.log("✅ HTML report generated at reports/cucumber-report.html");
// => Log: Output to console

{
  "scripts": {
    // => Config: npm script definitions
    "test:bdd": "npx cucumber-js",
    // => Script: test:bdd command
    "test:bdd:report": "npm run test:bdd && node scripts/generate-report.ts",
    // => Script: test:bdd:report command
    "test:bdd:open": "npm run test:bdd:report && open reports/cucumber-report.html"
    // => Script: test:bdd:open command
  }
}

// File: support/screenshot-hooks.ts  // => File: support/screenshot-hooks.ts
import { After, Status } from "@cucumber/cucumber";
// => Import: cucumber module
import { promises as fs } from "fs";
// => Import: fs module
 
After(async function (scenario) {
  // => After: Run after each scenario
  if (scenario.result?.status === Status.FAILED && this.page) {
    // => Condition: Only on failure with browser
 
    const screenshotPath = `reports/screenshots/${scenario.pickle.name}-${Date.now()}.png`;
    // => Path: Unique screenshot filename
    // => Includes: Scenario name + timestamp
 
    await this.page.screenshot({ path: screenshotPath, fullPage: true });
    // => Screenshot: Full page capture
    // => Playwright: Auto-waits for network idle
 
    const screenshot = await fs.readFile(screenshotPath);
    // => Read: Screenshot file
    await this.attach(screenshot, "image/png");
    // => Attach: Add to Cucumber report
    // => Report: Screenshot appears inline with failure
  }
  // => End: block
});
// => End: function/callback

Feature: Order Processing
  # => Feature: Groups related scenarios for Order Processing
 
  Scenario: Process bulk order
    # => Scenario: Single test case for Process bulk order
    Given the following products are available:
      # => Given: Establishes precondition
      | product  | stock | price  |
        # => Table: Column headers product | stock | price
      | Widget   | 100   | substantial amounts.00 |
        # => Row: Widget, 100, substantial amounts.00
      | Gadget   | 50    | substantial amounts.00 |
        # => Row: Gadget, 50, substantial amounts.00
      | Doohickey| 75    | substantial amounts.00 |
        # => Row: Doohickey, 75, substantial amounts.00
    When a bulk order is placed with:
      # => When: Performs action
      | product   | quantity |
        # => Table: Column headers product | quantity
      | Widget    | 25       |
        # => Row: Widget, 25
      | Gadget    | 10       |
        # => Row: Gadget, 10
    Then the order total should be substantial amounts.00
      # => Then: Asserts expected outcome
    And the remaining stock should be:
      # => And: Continues previous step type
      | product  | stock |
        # => Table: Column headers product | stock
      | Widget   | 75    |
        # => Row: Widget, 75
      | Gadget   | 40    |
        # => Row: Gadget, 40

// File: support/browser-config.ts
// => File: support/browser-config.ts
// => State: context updated
import { chromium, firefox, webkit, Browser, BrowserContext, Page } from "playwright";
// => Import: playwright module
// => State: context updated
 
export type BrowserType = "chromium" | "firefox" | "webkit";
// => Assign: Value stored
 
export class BrowserManager {
  // => Class: Manage browser instances
  // => State: context updated
  private browsers: Map<BrowserType, Browser> = new Map();
  // => Storage: Browser instances by type
  // => Instance: object created on heap
 
  async launchBrowser(browserType: BrowserType): Promise<Browser> {
    // => Method: Launch specific browser
    // => Effect: function side effects applied
    if (this.browsers.has(browserType)) {
      // => Check: evaluates condition
      // => Effect: function side effects applied
      return this.browsers.get(browserType)!;
      // => Cached: Reuse existing browser
      // => Caller: receives returned value
    }
    // => End: block
    // => State: context updated
 
    let browser: Browser;
    // => Declare: browser typed variable
    switch (browserType) {
      // => Execute: Statement runs
      case "chromium":
        // => Execute: statement runs
        // => State: context updated
        browser = await chromium.launch({ headless: true });
        // => Launch: Chromium (Chrome/Edge)
        // => Async: operation resolves to result
        break;
      // => Execute: Statement runs
      case "firefox":
        // => Execute: statement runs
        // => State: context updated
        browser = await firefox.launch({ headless: true });
        // => Launch: Firefox
        // => Async: operation resolves to result
        break;
      // => Execute: Statement runs
      case "webkit":
        // => Execute: statement runs
        // => State: context updated
        browser = await webkit.launch({ headless: true });
        // => Launch: WebKit (Safari)
        // => Async: operation resolves to result
        break;
      // => Execute: Statement runs
      default:
        // => Execute: Statement runs
        throw new Error(`Unknown browser: ${browserType}`);
      // => Throw: Error on invalid state
    }
    // => End: block
    // => State: context updated
 
    this.browsers.set(browserType, browser);
    // => Cache: Store for reuse
    // => Effect: function side effects applied
    return browser;
    // => Return: Function result
  }
  // => End: block
  // => State: context updated
 
  async createContext(browserType: BrowserType): Promise<BrowserContext> {
    // => Method: Create isolated browser context
    // => Effect: function side effects applied
    const browser = await this.launchBrowser(browserType);
    // => Browser: Get or launch browser
    // => Async: operation resolves to result
 
    const context = await browser.newContext({
      // => Var: context = await browser.newContext({
      // => Async: operation resolves to result
      viewport: { width: 1280, height: 720 },
      // => Viewport: Standard desktop resolution
      // => State: context updated
      userAgent: getUserAgent(browserType),
      // => User Agent: Browser-specific
      // => Effect: function side effects applied
      locale: "en-US",
      // => Locale: English US
      // => State: context updated
    });
    // => End: function/callback
    // => State: context updated
 
    return context;
    // => Return: Isolated context for scenario
    // => Caller: receives returned value
  }
  // => End: block
 
  async closeAll(): Promise<void> {
    // => Method: Close all browsers
    for (const browser of this.browsers.values()) {
      // => Loop: iterates collection
      await browser.close();
      // => Close: Clean up browser instance
    }
    // => End: block
    this.browsers.clear();
    // => Clear: Remove references
  }
  // => End: block
}
// => End: block
 
function getUserAgent(browserType: BrowserType): string {
  // => Function: Get user agent string
  // => Return browser-specific user agent  // => Note: Return browser-specific user agent
  return `Mozilla/5.0 (${browserType})`;
  // => Return: Function result
}
// => End: block