Gauge Framework Guide: Language-Independent BDD Alternative to Cucumber

# User Authentication

## Successful login with valid credentials
* Navigate to login page
* Enter username "john.doe@example.com"
* Enter password "SecurePass123"
* Click login button
* Verify user is redirected to dashboard
* Verify welcome message "Welcome, John"

## Failed login with invalid credentials
* Navigate to login page
* Enter username "john.doe@example.com"
* Enter password "wrongpassword"
* Click login button
* Verify error message "Invalid credentials"
* Verify user remains on login page

# E-Commerce Shopping Cart
tags: shopping, critical

## Context Setup
* Login as "standard_user"
* Navigate to products page

## Add product to cart
* Add product "Laptop Computer" to cart
* Verify cart count is "1"
* Verify cart total is "$999.99"

## Add multiple quantities
* Add "3" units of product "USB Cable" to cart
* Verify cart count is "3"
* Verify cart total is "$29.97"

## Remove product from cart
* Add product "Wireless Mouse" to cart
* Remove product "Wireless Mouse" from cart
* Verify cart is empty
* Verify cart count is "0"

# Login Validation
tags: validation, parametrized

## Validate login with different credentials
|username|password|expected_result|
|--------|--------|---------------|
|valid@example.com|ValidPass123|Welcome to Dashboard|
|invalid@example.com|anything|User not found|
|valid@example.com|wrongpass|Invalid credentials|
|@invalid.com|ValidPass123|Invalid email format|
|valid@example.com|123|Password too short|

* Verify login with credentials <username>, <password> shows <expected_result>

// src/test/java/StepImplementation.java
package com.example;

import com.thoughtworks.gauge.Step;
import com.thoughtworks.gauge.Table;
import com.thoughtworks.gauge.TableRow;
import pages.LoginPage;
import pages.DashboardPage;

public class StepImplementation {
    private LoginPage loginPage;
    private DashboardPage dashboardPage;

    @Step("Navigate to login page")
    public void navigateToLogin() {
        loginPage = new LoginPage();
        loginPage.open();
    }

    @Step("Enter username <username>")
    public void enterUsername(String username) {
        loginPage.enterUsername(username);
    }

    @Step("Enter password <password>")
    public void enterPassword(String password) {
        loginPage.enterPassword(password);
    }

    @Step("Click login button")
    public void clickLogin() {
        dashboardPage = loginPage.clickLogin();
    }

    @Step("Verify user is redirected to dashboard")
    public void verifyDashboard() {
        assertTrue(dashboardPage.isDisplayed());
    }

    @Step("Verify login with credentials <username>, <password> shows <result>")
    public void verifyLoginWithCredentials(String username, String password, String result) {
        navigateToLogin();
        enterUsername(username);
        enterPassword(password);
        clickLogin();
        assertEquals(result, loginPage.getMessageOrDashboardText());
    }
}

// tests/step_implementations/authentication.ts
import { Step, Table } from "gauge-ts";
import { LoginPage } from "../pages/LoginPage";
import { DashboardPage } from "../pages/DashboardPage";
import { expect } from "@playwright/test";

let loginPage: LoginPage;
let dashboardPage: DashboardPage;

Step("Navigate to login page", async function() {
    loginPage = new LoginPage(gauge.page);
    await loginPage.navigate();
});

Step("Enter username <username>", async function(username: string) {
    await loginPage.enterUsername(username);
});

Step("Enter password <password>", async function(password: string) {
    await loginPage.enterPassword(password);
});

Step("Click login button", async function() {
    await loginPage.clickLogin();
    dashboardPage = new DashboardPage(gauge.page);
});

Step("Verify user is redirected to dashboard", async function() {
    await expect(dashboardPage.container).toBeVisible();
});

Step("Verify welcome message <message>", async function(message: string) {
    const actual = await dashboardPage.getWelcomeMessage();
    expect(actual).toBe(message);
});

Step("Verify login with credentials <username>, <password> shows <result>",
    async function(username: string, password: string, expectedResult: string) {
        await loginPage.navigate();
        await loginPage.enterUsername(username);
        await loginPage.enterPassword(password);
        await loginPage.clickLogin();

        const actualResult = await loginPage.getMessageOrDashboardText();
        expect(actualResult).toContain(expectedResult);
});

# step_impl/authentication_steps.py
from getgauge.python import step, Table
from pages.login_page import LoginPage
from pages.dashboard_page import DashboardPage

login_page = None
dashboard_page = None

@step("Navigate to login page")
def navigate_to_login():
    global login_page
    login_page = LoginPage()
    login_page.navigate()

@step("Enter username <username>")
def enter_username(username):
    login_page.enter_username(username)

@step("Enter password <password>")
def enter_password(password):
    login_page.enter_password(password)

@step("Click login button")
def click_login():
    global dashboard_page
    login_page.click_login()
    dashboard_page = DashboardPage()

@step("Verify user is redirected to dashboard")
def verify_dashboard_redirect():
    assert dashboard_page.is_displayed(), "Dashboard not displayed"

@step("Verify welcome message <message>")
def verify_welcome_message(message):
    actual = dashboard_page.get_welcome_message()
    assert actual == message, f"Expected '{message}', got '{actual}'"

@step("Verify login with credentials <username>, <password> shows <result>")
def verify_login_credentials(username, password, expected_result):
    navigate_to_login()
    enter_username(username)
    enter_password(password)
    click_login()

    actual_result = login_page.get_message_or_dashboard_text()
    assert expected_result in actual_result

# env/default/default.properties

# Number of parallel streams
gauge_parallel_streams = 4

# Execution strategy: lazy (default) or eager
gauge_execution_type = lazy

# Enable/disable screenshots on failure
screenshot_on_failure = true

# Report configuration
gauge_reports_dir = reports
overwrite_reports = true

# Browser configuration for parallel execution
BROWSER = chrome
HEADLESS = true

# Run with 4 parallel streams
gauge run specs --parallel --max-workers=4

# Run specific tags in parallel
gauge run specs --tags "smoke & critical" --parallel

# Parallel execution with custom streams
gauge run specs --parallel --max-workers=8 --strategy=eager

# Parallel with custom environment
gauge run specs --env qa --parallel --max-workers=4

<!-- concepts/login_concepts.cpt -->

# Login as user <username> with password <password>
* Navigate to login page
* Enter username <username>
* Enter password <password>
* Click login button

# Login as admin
* Login as user "admin@example.com" with password "admin123"
* Verify admin dashboard is displayed

# Login as standard user
* Login as user "user@example.com" with password "user123"
* Verify user dashboard is displayed

# Add product <product_name> to cart
* Search for product <product_name>
* Click on product <product_name>
* Click add to cart button
* Verify product added confirmation

# Complete checkout with <payment_method>
* Navigate to cart
* Click checkout button
* Fill shipping information
* Select payment method <payment_method>
* Confirm order
* Verify order confirmation

# E-Commerce Complete Flow
tags: integration, e2e

## Successful purchase flow
* Login as standard user
* Add product "Laptop Pro" to cart
* Add product "Wireless Mouse" to cart
* Complete checkout with "Credit Card"
* Verify order total is "$1,029.98"
* Verify order confirmation email sent

## Guest checkout
* Add product "USB Cable" to cart
* Complete checkout with "PayPal"
* Verify order confirmation page

// src/test/java/Hooks.java
package com.example;

import com.thoughtworks.gauge.*;
import org.openqa.selenium.WebDriver;
import utils.DriverFactory;
import utils.DatabaseUtils;

public class Hooks {
    private WebDriver driver;

    @BeforeSuite
    public void beforeSuite(ExecutionContext context) {
        System.out.println("Starting test suite: " +
                          context.getCurrentSpecification().getName());
        DatabaseUtils.initializeTestDatabase();
    }

    @BeforeSpec
    public void beforeSpec(ExecutionContext context) {
        System.out.println("Starting spec: " +
                          context.getCurrentSpecification().getName());
    }

    @BeforeScenario
    public void beforeScenario(ExecutionContext context) {
        System.out.println("Starting scenario: " +
                          context.getCurrentScenario().getName());
        driver = DriverFactory.getDriver();
        Gauge.writeMessage("Browser launched");
    }

    @BeforeStep
    public void beforeStep(ExecutionContext context) {
        // Can be used for logging or screenshots
    }

    @AfterStep
    public void afterStep(ExecutionContext context) {
        if (context.getCurrentStep().getIsFailing()) {
            byte[] screenshot = DriverFactory.takeScreenshot(driver);
            Gauge.writeMessage("Step failed, screenshot attached");
        }
    }

    @AfterScenario
    public void afterScenario(ExecutionContext context) {
        if (context.getCurrentScenario().getIsFailing()) {
            byte[] screenshot = DriverFactory.takeScreenshot(driver);
            Gauge.captureScreenshot();
        }
        driver.quit();
    }

    @AfterSpec
    public void afterSpec(ExecutionContext context) {
        System.out.println("Completed spec: " +
                          context.getCurrentSpecification().getName());
    }

    @AfterSuite
    public void afterSuite(ExecutionContext context) {
        System.out.println("Test suite completed");
        DatabaseUtils.cleanupTestDatabase();
    }
}

# User Login
tags: authentication

## Successful login
* Navigate to login page
* Login as user "john@example.com" with password "pass123"
* Verify dashboard is displayed

@authentication
Feature: User Login

  Scenario: Successful login
    Given I navigate to login page
    When I login as user "john@example.com" with password "pass123"
    Then I should see the dashboard

# Install essential plugins
gauge install java
gauge install javascript
gauge install python
gauge install html-report
gauge install xml-report
gauge install json-report
gauge install screenshot
gauge install spectacle  # Beautiful HTML reports

# Install IDE plugins
# VS Code: Search "Gauge" in extensions
# IntelliJ IDEA: File -> Settings -> Plugins -> Gauge

# List installed plugins
gauge list

# Update plugins
gauge update --all

# Complete E-Commerce Purchase Flow
tags: critical, integration, e2e

## Context: Product catalog setup
* Initialize database with test products
* Ensure inventory stock levels are sufficient

## Guest user completes purchase
* Navigate to home page
* Search for product "Laptop Pro 15"
* Add product to cart with quantity "1"
* Proceed to checkout as guest
* Fill guest checkout information
  |field|value|
  |-----|-----|
  |email|guest@example.com|
  |firstName|John|
  |lastName|Doe|
  |address|123 Main St|
  |city|San Francisco|
  |state|CA|
  |zip|94105|
  |country|USA|
* Select shipping method "Standard"
* Enter payment details
  |cardNumber|expiry|cvv|name|
  |----------|------|---|-----|
  |4532123456789010|12/25|123|John Doe|
* Submit order
* Verify order confirmation number is generated
* Verify order confirmation email sent to "guest@example.com"
* Verify inventory decreased for "Laptop Pro 15"

## Registered user with saved details
* Login as standard user
* Search for product "Wireless Mouse"
* Add product to cart with quantity "2"
* Proceed to checkout
* Select saved shipping address "Home"
* Select saved payment method "Visa ending 9010"
* Apply coupon code "SAVE10"
* Verify discount applied is "10%"
* Submit order
* Verify order total is "$53.99"
* Verify loyalty points earned "54"

<!-- Good: Declarative, business-focused -->
* Login as admin
* Add product to cart
* Complete checkout

<!-- Bad: Imperative, UI-focused -->
* Click on login link
* Type "admin" in username field
* Type "pass" in password field
* Click submit button

<!-- Reusable concept -->
# Purchase product <name> as <user_type>
* Login as <user_type>
* Search and add <name> to cart
* Complete checkout with default payment
* Verify order confirmation

<!-- Usage in spec -->
* Purchase product "Laptop" as "premium_user"
* Purchase product "Mouse" as "standard_user"