BDD Automation Interview Prep Track

src/
├── test/
│   ├── java/
│   │   ├── base/            ← BaseTest class (driver setup)
│   │   ├── pages/           ← Page Object Model classes
│   │   ├── stepdefinitions/ ← Cucumber step bindings
│   │   ├── hooks/           ← @Before / @After lifecycle
│   │   ├── runners/         ← CucumberOptions runner class
│   │   └── utilities/       ← Screenshot, Wait, Excel helpers
│   └── resources/
│       ├── features/        ← .feature files (Gherkin scenarios)
│       ├── config/          ← config.properties (env settings)
│       └── testdata/        ← Excel / JSON test data files

<!-- pom.xml — Core BDD Framework Dependencies -->
<dependencies>
  <!-- Selenium WebDriver -->
  <dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>4.18.1</version>
  </dependency>

  <!-- Cucumber Java Bindings -->
  <dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-java</artifactId>
    <version>7.15.0</version>
  </dependency>

  <!-- Cucumber TestNG Integration -->
  <dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-testng</artifactId>
    <version>7.15.0</version>
  </dependency>

  <!-- WebDriverManager — Auto driver downloads -->
  <dependency>
    <groupId>io.github.bonigarcia</groupId>
    <artifactId>webdrivermanager</artifactId>
    <version>5.7.0</version>
  </dependency>

  <!-- Apache POI — Excel data handling -->
  <dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.2.5</version>
  </dependency>

  <!-- Log4j — Execution logging -->
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.23.1</version>
  </dependency>
</dependencies>

public class BaseTest {
    protected static ThreadLocal<WebDriver> driver = new ThreadLocal<>();

    public static WebDriver getDriver() {
        return driver.get();
    }

    public void setup(String browser) {
        WebDriver webDriver;
        switch (browser.toLowerCase()) {
            case "firefox":
                WebDriverManager.firefoxdriver().setup();
                webDriver = new FirefoxDriver();
                break;
            case "edge":
                WebDriverManager.edgedriver().setup();
                webDriver = new EdgeDriver();
                break;
            default:
                WebDriverManager.chromedriver().setup();
                webDriver = new ChromeDriver();
        }
        webDriver.manage().window().maximize();
        webDriver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        driver.set(webDriver);
    }

    public void tearDown() {
        if (getDriver() != null) {
            getDriver().quit();
            driver.remove(); // Important for thread safety in parallel runs
        }
    }
}

// Old approach (manual) — AVOID in modern frameworks
System.setProperty("webdriver.chrome.driver", "drivers/chromedriver.exe");

// ✅ Modern approach — WebDriverManager handles everything
WebDriverManager.chromedriver().setup();
WebDriver driver = new ChromeDriver();

// Firefox
WebDriverManager.firefoxdriver().setup();
WebDriver driver = new FirefoxDriver();

// Edge
WebDriverManager.edgedriver().setup();
WebDriver driver = new EdgeDriver();

// Headless Chrome (for CI/CD pipelines)
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless", "--no-sandbox", "--disable-dev-shm-usage");
WebDriverManager.chromedriver().setup();
WebDriver driver = new ChromeDriver(options);

// LoginPage.java
public class LoginPage extends BaseTest {

    // Element locators using @FindBy (PageFactory)
    @FindBy(id = "username")
    private WebElement usernameField;

    @FindBy(id = "password")
    private WebElement passwordField;

    @FindBy(css = "button[type='submit']")
    private WebElement loginButton;

    @FindBy(css = ".error-message")
    private WebElement errorMessage;

    // Constructor — initializes PageFactory
    public LoginPage(WebDriver driver) {
        PageFactory.initElements(driver, this);
    }

    // Actions — clean, readable method names
    public void enterUsername(String username) {
        usernameField.clear();
        usernameField.sendKeys(username);
    }

    public void enterPassword(String password) {
        passwordField.clear();
        passwordField.sendKeys(password);
    }

    public void clickLogin() {
        loginButton.click();
    }

    public String getErrorMessage() {
        return errorMessage.getText();
    }

    // Chained method for fluent style
    public DashboardPage loginAs(String user, String pass) {
        enterUsername(user);
        enterPassword(pass);
        clickLogin();
        return new DashboardPage(getDriver());
    }
}

# src/test/resources/features/Login.feature
Feature: Login Functionality
  As a registered user
  I want to login to the application
  So that I can access my account

  Background:
    Given the application is launched on "chrome"
    And the user navigates to the login page

  @smoke @regression
  Scenario: Successful login with valid credentials
    When the user enters username "admin@example.com"
    And the user enters password "Admin@123"
    And the user clicks the login button
    Then the user should be redirected to the Dashboard
    And the welcome message should display "Welcome, Admin"

  @negative
  Scenario: Login fails with invalid password
    When the user enters username "admin@example.com"
    And the user enters password "wrongpassword"
    And the user clicks the login button
    Then the error message "Invalid credentials" should be displayed

  @datadriven
  Scenario Outline: Login with multiple user types
    When the user enters username "<username>"
    And the user enters password "<password>"
    And the user clicks the login button
    Then the dashboard heading "<heading>" should be visible

    Examples:
      | username          | password   | heading        |
      | admin@test.com    | Admin@123  | Admin Panel    |
      | manager@test.com  | Mgr@456    | Manager View   |
      | user@test.com     | User@789   | User Dashboard |

// LoginSteps.java
public class LoginSteps {

    private LoginPage loginPage;
    private DashboardPage dashboardPage;

    @Given("the application is launched on {string}")
    public void theApplicationIsLaunched(String browser) {
        BaseTest.setup(browser);
        loginPage = new LoginPage(BaseTest.getDriver());
    }

    @Given("the user navigates to the login page")
    public void theUserNavigatesToLoginPage() {
        String url = ConfigReader.get("url");
        BaseTest.getDriver().get(url);
    }

    @When("the user enters username {string}")
    public void theUserEntersUsername(String username) {
        loginPage.enterUsername(username);
    }

    @When("the user enters password {string}")
    public void theUserEntersPassword(String password) {
        loginPage.enterPassword(password);
    }

    @When("the user clicks the login button")
    public void theUserClicksLoginButton() {
        dashboardPage = loginPage.clickLogin();
    }

    @Then("the user should be redirected to the Dashboard")
    public void theUserShouldBeRedirectedToDashboard() {
        Assert.assertTrue(
            dashboardPage.isLoaded(),
            "Dashboard was not loaded after login."
        );
    }

    @Then("the error message {string} should be displayed")
    public void theErrorMessageShouldBeDisplayed(String expectedMsg) {
        String actual = loginPage.getErrorMessage();
        Assert.assertEquals(actual, expectedMsg,
            "Error message mismatch.");
    }
}

// TestRunner.java
@RunWith(Cucumber.class)
@CucumberOptions(
    // Path to .feature files
    features = "src/test/resources/features",

    // Package containing step definition classes
    glue = {"stepdefinitions", "hooks"},

    // Tag filtering — run specific tagged scenarios
    tags = "@smoke",

    // Reporting plugins
    plugin = {
        "pretty",                                     // Console formatting
        "html:target/cucumber-reports/report.html",   // HTML report
        "json:target/cucumber-reports/report.json",   // JSON for Extent/Allure
        "junit:target/cucumber-reports/report.xml",   // JUnit for Jenkins
        "io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm"  // Allure
    },

    // Publish to Cucumber cloud report
    publish = false,

    // Print step snippets for unimplemented steps
    snippets = SnippetType.CAMELCASE,

    // Show or suppress @tags in reports
    dryRun = false,
    monochrome = true
)
public class TestRunner extends AbstractTestNGCucumberTests {

    // Override for parallel execution support
    @Override
    @DataProvider(parallel = true)
    public Object[][] scenarios() {
        return super.scenarios();
    }
}

// Hooks.java
public class Hooks extends BaseTest {

    private final Scenario scenario;

    // Cucumber injects the Scenario object automatically
    public Hooks(Scenario scenario) {
        this.scenario = scenario;
    }

    @Before(order = 1)
    public void beforeScenario() {
        // Read browser from config file
        String browser = ConfigReader.get("browser");
        setup(browser); // Launch browser from BaseTest

        // Navigate to application URL
        getDriver().get(ConfigReader.get("url"));

        LogManager.getLogger().info(
            "▶ Starting Scenario: " + scenario.getName()
        );
    }

    @After(order = 1)
    public void afterScenario() {
        // Capture screenshot on failure
        if (scenario.isFailed()) {
            byte[] screenshot = ((TakesScreenshot) getDriver())
                .getScreenshotAs(OutputType.BYTES);
            scenario.attach(screenshot, "image/png", "Failure Screenshot");

            LogManager.getLogger().error(
                "❌ Scenario FAILED: " + scenario.getName()
            );
        }

        // Always close the browser
        tearDown();
    }

    // Tagged hooks — only run for specific tags
    @Before("@clearCookies")
    public void clearCookies() {
        getDriver().manage().deleteAllCookies();
    }
}

// WaitUtility.java
public class WaitUtility {

    // Explicit wait — waits for a specific condition
    public static WebElement waitForVisible(By locator, int seconds) {
        WebDriverWait wait = new WebDriverWait(
            BaseTest.getDriver(), Duration.ofSeconds(seconds)
        );
        return wait.until(
            ExpectedConditions.visibilityOfElementLocated(locator)
        );
    }

    public static boolean waitForInvisible(By locator, int seconds) {
        WebDriverWait wait = new WebDriverWait(
            BaseTest.getDriver(), Duration.ofSeconds(seconds)
        );
        return wait.until(
            ExpectedConditions.invisibilityOfElementLocated(locator)
        );
    }

    public static WebElement waitForClickable(By locator, int seconds) {
        WebDriverWait wait = new WebDriverWait(
            BaseTest.getDriver(), Duration.ofSeconds(seconds)
        );
        return wait.until(
            ExpectedConditions.elementToBeClickable(locator)
        );
    }
}

// ScreenshotUtility.java
public class ScreenshotUtility {

    public static byte[] captureAsBytes(WebDriver driver) {
        return ((TakesScreenshot) driver)
            .getScreenshotAs(OutputType.BYTES);
    }

    public static void saveToFile(WebDriver driver, String fileName) {
        File src = ((TakesScreenshot) driver)
            .getScreenshotAs(OutputType.FILE);
        try {
            FileUtils.copyFile(src,
                new File("target/screenshots/" + fileName + ".png")
            );
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// ❌ NEVER use Thread.sleep — wastes time unconditionally
Thread.sleep(3000); // Freezes for 3 seconds regardless of element state

// ❌ AVOID Implicit Wait — applies globally, masks real timing issues
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

// ✅ BEST: Explicit Wait — waits only until condition is met
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));

// Wait for element to be visible
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("dashboard")));

// Wait for text to appear
wait.until(ExpectedConditions.textToBePresentInElement(heading, "Welcome"));

// Wait for URL to change
wait.until(ExpectedConditions.urlContains("/dashboard"));

// ✅ Fluent Wait — custom polling interval + exception ignore
Wait<WebDriver> fluentWait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofMillis(500))
    .ignoring(NoSuchElementException.class)
    .withMessage("Element not found after 30 seconds");

fluentWait.until(d -> d.findElement(By.id("loader")).isDisplayed() == false);

# src/test/resources/config/config.properties
browser=chrome
url=https://staging.example.com
username=admin@example.com
password=Admin@123
timeout=15
headless=false

---

// ConfigReader.java — Reads config.properties at runtime
public class ConfigReader {
    private static Properties properties;

    static {
        try {
            FileInputStream fis = new FileInputStream(
                "src/test/resources/config/config.properties"
            );
            properties = new Properties();
            properties.load(fis);
        } catch (IOException e) {
            throw new RuntimeException("Cannot load config.properties", e);
        }
    }

    public static String get(String key) {
        String value = properties.getProperty(key);
        if (value == null) {
            throw new RuntimeException("Key '" + key + "' not found in config.");
        }
        return value.trim();
    }

    public static int getInt(String key) {
        return Integer.parseInt(get(key));
    }

    public static boolean getBoolean(String key) {
        return Boolean.parseBoolean(get(key));
    }
}

// ExcelUtility.java — Read data from Excel using Apache POI
public class ExcelUtility {

    public static String getCellData(String filePath, String sheetName,
                                      int row, int col) throws Exception {
        FileInputStream fis = new FileInputStream(filePath);
        Workbook workbook = WorkbookFactory.create(fis);
        Sheet sheet = workbook.getSheet(sheetName);
        Row excelRow = sheet.getRow(row);
        Cell cell = excelRow.getCell(col);
        workbook.close();
        return cell.toString();
    }

    public static List<Map<String, String>> getAllRows(String filePath,
                                                        String sheetName)
            throws Exception {
        FileInputStream fis = new FileInputStream(filePath);
        Workbook workbook = WorkbookFactory.create(fis);
        Sheet sheet = workbook.getSheet(sheetName);
        List<Map<String, String>> data = new ArrayList<>();
        Row header = sheet.getRow(0);

        for (int i = 1; i <= sheet.getLastRowNum(); i++) {
            Row row = sheet.getRow(i);
            Map<String, String> rowData = new LinkedHashMap<>();
            for (int j = 0; j < header.getLastCellNum(); j++) {
                rowData.put(
                    header.getCell(j).toString(),
                    row.getCell(j).toString()
                );
            }
            data.add(rowData);
        }
        workbook.close();
        return data;
    }
}

// ExtentReportManager.java — Singleton pattern for thread-safe reporting
public class ExtentReportManager {
    private static ExtentReports extent;

    public static ExtentReports getInstance() {
        if (extent == null) {
            ExtentSparkReporter spark = new ExtentSparkReporter(
                "target/reports/ExtentReport.html"
            );
            spark.config().setTheme(Theme.DARK);
            spark.config().setDocumentTitle("BDD Automation Report");
            spark.config().setReportName("Regression Suite Results");

            extent = new ExtentReports();
            extent.attachReporter(spark);
            extent.setSystemInfo("Environment", "Staging");
            extent.setSystemInfo("Browser", ConfigReader.get("browser"));
            extent.setSystemInfo("OS", System.getProperty("os.name"));
        }
        return extent;
    }
}

// Usage inside Hooks.java
@After
public void afterScenario(Scenario scenario) {
    ExtentTest test = ExtentReportManager.getInstance()
        .createTest(scenario.getName());

    if (scenario.isFailed()) {
        test.fail("Scenario failed — attaching screenshot.")
            .addScreenCaptureFromBase64String(
                ScreenshotUtility.captureAsBase64(getDriver())
            );
    } else {
        test.pass("Scenario passed successfully.");
    }

    ExtentReportManager.getInstance().flush();
}

// Full screenshot strategy in Hooks.java
@After
public void captureFailureScreenshot(Scenario scenario) {
    if (scenario.isFailed()) {

        // Method 1: Attach to Cucumber Scenario (shows in all reports)
        byte[] screenshot = ((TakesScreenshot) getDriver())
            .getScreenshotAs(OutputType.BYTES);
        scenario.attach(screenshot, "image/png",
            "Failure: " + scenario.getName());

        // Method 2: Save to disk with timestamp
        String timestamp = LocalDateTime.now()
            .format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss"));
        String fileName = scenario.getName().replaceAll("\s+", "_")
            + "_" + timestamp;
        ScreenshotUtility.saveToFile(getDriver(), fileName);

        // Method 3: Log failure details
        LogManager.getLogger().error(
            "❌ FAILED: " + scenario.getName() +
            " | Tags: " + scenario.getSourceTagNames()
        );
    }
}

# log4j2.xml — Log4j2 configuration
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <!-- Console output -->
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout
        pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
    <!-- File output -->
    <File name="LogFile" fileName="target/logs/automation.log" append="false">
      <PatternLayout
        pattern="%d{yyyy-MM-dd HH:mm:ss} %-5level [%thread] %logger - %msg%n"/>
    </File>
  </Appenders>
  <Loggers>
    <Root level="info">
      <AppenderRef ref="Console"/>
      <AppenderRef ref="LogFile"/>
    </Root>
  </Loggers>
</Configuration>

---

// Usage in Java classes
private static final Logger logger = LogManager.getLogger(LoginSteps.class);

logger.info("▶ Navigating to login page: " + url);
logger.debug("Username field located: " + element.isDisplayed());
logger.warn("⚠ Element took longer than expected to load.");
logger.error("❌ Login failed — element not found: " + e.getMessage());

// config.properties — Single line change to switch browser
browser=firefox   # Change to: chrome | firefox | edge

// BaseTest.java — Dynamic browser resolution
public void setup(String browser) {
    WebDriver webDriver = switch (browser.toLowerCase()) {
        case "firefox" -> {
            WebDriverManager.firefoxdriver().setup();
            yield new FirefoxDriver();
        }
        case "edge" -> {
            WebDriverManager.edgedriver().setup();
            EdgeOptions options = new EdgeOptions();
            yield new EdgeDriver(options);
        }
        default -> {  // chrome
            WebDriverManager.chromedriver().setup();
            ChromeOptions options = new ChromeOptions();
            yield new ChromeDriver(options);
        }
    };
    webDriver.manage().window().maximize();
    driver.set(webDriver);
}

// Maven command — override browser at runtime
mvn test -Dbrowser=firefox -Denv=staging

// TestRunner.java — Enable parallel execution
@RunWith(Cucumber.class)
@CucumberOptions(
    features = "src/test/resources/features",
    glue = {"stepdefinitions", "hooks"},
    plugin = {"pretty", "html:target/cucumber-reports/report.html"},
    tags = "@regression"
)
public class TestRunner extends AbstractTestNGCucumberTests {

    // This override enables parallel scenario execution
    @Override
    @DataProvider(parallel = true)
    public Object[][] scenarios() {
        return super.scenarios();
    }
}

---

<!-- testng.xml — Configure thread count -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="BDD Regression Suite" parallel="methods" thread-count="4"
       verbose="1" data-provider-thread-count="4">
  <test name="Parallel BDD Tests">
    <classes>
      <class name="runners.TestRunner"/>
    </classes>
  </test>
</suite>

---

// Maven command for parallel execution
mvn test -Dthreads=4

// Jenkinsfile — Declarative Pipeline for BDD automation
pipeline {
    agent any

    environment {
        BROWSER = 'chrome'
        ENV = 'staging'
    }

    stages {
        stage('Checkout Code') {
            steps {
                git branch: 'main',
                    url: 'https://github.com/org/bdd-automation.git'
            }
        }

        stage('Build & Install Dependencies') {
            steps {
                sh 'mvn clean install -DskipTests'
            }
        }

        stage('Run BDD Regression Suite') {
            steps {
                sh """
                    mvn test \
                        -Dbrowser=${BROWSER} \
                        -Denv=${ENV} \
                        -Dcucumber.filter.tags=@regression \
                        -Dthreads=4
                """
            }
        }

        stage('Publish Test Reports') {
            steps {
                // Publish JUnit XML results
                junit 'target/cucumber-reports/*.xml'
                // Publish Allure report
                allure includeProperties: false,
                       jdk: '',
                       results: [[path: 'target/allure-results']]
            }
        }
    }

    post {
        failure {
            emailext(
                subject: '❌ BDD Suite FAILED: ${BUILD_NUMBER}',
                body: 'Tests failed. See: ${BUILD_URL}',
                to: 'qa-team@company.com'
            )
        }
        always {
            cleanWs()
        }
    }
}

# Git workflow for automation teams

# Initial setup — clone the automation repository
git clone https://github.com/org/bdd-automation.git
cd bdd-automation

# Create a feature branch for new test work
git checkout -b feature/JIRA-123-login-automation

# Stage and commit your changes
git add src/test/resources/features/Login.feature
git add src/test/java/stepdefinitions/LoginSteps.java
git add src/test/java/pages/LoginPage.java

git commit -m "feat(JIRA-123): Add BDD login automation with edge case coverage"

# Push to remote repository
git push origin feature/JIRA-123-login-automation

# Keep your branch up to date with main
git fetch origin
git rebase origin/main

# Merge via pull request (never commit directly to main)

# Useful commands
git log --oneline -10           # Last 10 commits
git diff main..HEAD             # Changes vs main branch
git stash                       # Temporarily save uncommitted work
git tag v1.0.0-regression       # Tag a stable suite version

// DbUtility.java — Direct JDBC helper
public class DbUtility {
    private static Connection conn;

    public static void establishConnection() throws SQLException {
        String dbUrl = ConfigReader.get("db.url");
        String user = ConfigReader.get("db.username");
        String password = ConfigReader.get("db.password");
        conn = DriverManager.getConnection(dbUrl, user, password);
    }

    public static ResultSet executeQuery(String query) throws SQLException {
        Statement stmt = conn.createStatement();
        return stmt.executeQuery(query);
    }

    public static void closeConnection() throws SQLException {
        if (conn != null && !conn.isClosed()) {
            conn.close();
        }
    }
}

// Step Definition assertion
@Then("the user record should exist in the database with status {string}")
public void verifyUserInDatabase(String expectedStatus) throws Exception {
    String query = "SELECT status FROM users WHERE email = '" + pm.environment.get("tempEmail") + "'";
    DbUtility.establishConnection();
    ResultSet rs = DbUtility.executeQuery(query);
    
    Assert.assertTrue(rs.next(), "User record not found in database.");
    String actualStatus = rs.getString("status");
    Assert.assertEquals(actualStatus, expectedStatus, "Database status mismatch.");
    DbUtility.closeConnection();
}

<!-- Add dependency to pom.xml -->
<dependency>
  <groupId>io.cucumber</groupId>
  <artifactId>cucumber-picocontainer</artifactId>
  <version>7.15.0</version>
  <scope>test</scope>
</dependency>

---

// 1. Create a Shared Context Class
public class TestContext {
    public WebDriver driver;
    public Map<String, Object> scenarioData = new HashMap<>();
}

// 2. Inject into Step Definition A
public class LoginSteps {
    private final TestContext context;

    public LoginSteps(TestContext context) {
        this.context = context;
    }

    @Given("the user is logged in")
    public void userLoggedIn() {
        context.scenarioData.put("userId", "12345");
    }
}

// 3. Inject into Step Definition B (Shares the same context instance!)
public class OrderSteps {
    private final TestContext context;

    public OrderSteps(TestContext context) {
        this.context = context;
    }

    @Then("the order should be placed for the logged-in user")
    public void verifyOrder() {
        String userId = (String) context.scenarioData.get("userId");
        System.out.println("Placing order for user: " + userId);
    }
}

// TestRunner.java
@CucumberOptions(
    features = "src/test/resources/features",
    glue = {"stepdefinitions", "hooks"},
    dryRun = true,  // <-- Set to true for validation
    monochrome = true,
    plugin = {"pretty"}
)
public class DryRunner extends AbstractTestNGCucumberTests {}

// Dynamic run from Maven console
mvn test -Dcucumber.plugin="pretty" -Dcucumber.features="src/test/resources" -Dcucumber.execution.dry-run=true

// Switching to an iframe step
@When("the user fills payment details inside the secure frame")
public void fillDetailsInFrame() {
    WebDriver driver = BaseTest.getDriver();
    WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    
    // 1. Wait for frame and switch
    wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(By.id("stripe-frame")));
    
    // 2. Interact with element inside frame
    driver.findElement(By.id("card-number")).sendKeys("4242 4242 4242");
    
    // 3. Switch back to default content
    driver.switchTo().defaultContent();
}

// Switching to a newly opened tab
@Then("the terms page should open in a new window tab")
public void switchToTab() {
    WebDriver driver = BaseTest.getDriver();
    String parentWindow = driver.getWindowHandle();
    
    // Wait until there are exactly 2 windows open
    new WebDriverWait(driver, Duration.ofSeconds(5))
        .until(d -> d.getWindowHandles().size() == 2);
        
    for (String windowHandle : driver.getWindowHandles()) {
        if (!windowHandle.equals(parentWindow)) {
            driver.switchTo().window(windowHandle);
            break;
        }
    }
    Assert.assertTrue(driver.getCurrentUrl().contains("/terms-of-service"));
    driver.close(); // Close tab
    driver.switchTo().window(parentWindow); // Switch back
}

# Example of tagged scenarios
@smoke @regression
Scenario: Verify smoke login
  Given user is on login page

@regression @slow @database
Scenario: Verify database sync
  Given user triggers bulk sync

---

# Execute in TestRunner.java:
tags = "@regression and not @slow"  # Run regression, skip slow

# Execute from Maven CLI:
mvn test -Dcucumber.filter.tags="@smoke or (@regression and not @database)"

# Scenario Outline: Runs 3 separate times (3 browser setups/teardowns)
Scenario Outline: Login with multi-roles
  When user logs in as "<role>"
  Then dashboard should show "<access>"
  Examples:
    | role   | access   |
    | admin  | Full     |
    | member | ReadOnly |

---

# Step Data Table: Runs ONCE (passes grid of data to one step)
Scenario: Create user with profile data
  When the user submits the profile registration form:
    | Field      | Value            |
    | FirstName  | Alex             |
    | LastName   | SDET             |
    | Department | Quality Assurance|

// Step definition executing Rest-Assured API setup
@Given("a product exists in the system with name {string}")
public void apiProductSetup(String productName) {
    // 1. Send fast backend API request to create the product
    Response response = RestAssured.given()
        .header("Content-Type", "application/json")
        .body("{\"name\":\"" + productName + "\",\"price\":99.99}")
        .post("https://api.example.com/products");
        
    Assert.assertEquals(response.getStatusCode(), 201);
    String productId = response.jsonPath().getString("id");
    pm.environment.set("tempProductId", productId); // Save ID for UI use
}

@When("the user searches for the product on the shop dashboard")
public void uiProductSearch() {
    // 2. Open browser and search via UI
    BaseTest.getDriver().get("https://shop.example.com");
    shopPage.searchFor(pm.environment.get("tempProductId"));
}

// Enforcing resolutions inside BaseTest.java for Headless Chrome
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless");
options.addArguments("--no-sandbox");
options.addArguments("--disable-dev-shm-usage");

// Crucial: Headless browsers default to tiny sizes! Explicitly set resolution:
options.addArguments("--window-size=1920,1080");

WebDriver driver = new ChromeDriver(options);
// Double-enforce size
driver.manage().window().setSize(new Dimension(1920, 1080));

// TestRunner.java Options
@CucumberOptions(
    features = "src/test/resources/features",
    glue = {"stepdefinitions"},
    monochrome = true, // Strips ANSI codes, clean plain text logs
    plugin = {
        "pretty", 
        "html:target/report.html"
    }
)
public class MonochromeRunner extends AbstractTestNGCucumberTests {}

// ConfigReader.java - Resolving dynamic command-line parameters
public class ConfigReader {
    private static Properties properties;

    static {
        try {
            // 1. Get environment key from Maven CLI -Denv=... (default to 'qa')
            String env = System.getProperty("env");
            if (env == null) env = "qa";
            
            String configPath = "src/test/resources/config/" + env + "-config.properties";
            FileInputStream fis = new FileInputStream(configPath);
            properties = new Properties();
            properties.load(fis);
        } catch (IOException e) {
            throw new RuntimeException("Failed to load env configurations.", e);
        }
    }

    public static String get(String key) {
        // Allow command line property overrides over file property overrides
        String systemProp = System.getProperty(key);
        if (systemProp != null) return systemProp;
        return properties.getProperty(key);
    }
}

// ❌ Conflict: Both regexes match "Given the user clicks on login"
@Given("^the user clicks on (.*)$")
public void clickAny(String element) {}

@Given("^the user clicks on login$")
public void clickLogin() {}

// ✅ Resolution: Refine regex bounds or use exact Cucumber Expressions
@Given("the user clicks on {string}") // Matches specific quoted text only
public void clickSpecific(String element) {}

@Given("the user clicks on the login button") // Strict string match
public void clickLoginStrict() {}

# Feature file tagged with Jira Test ID
@Jira-TEST-4561 @regression
Scenario: Verify checkout payment flow
  Given user has items in cart
  When user completes payment

---

# Groovy Jenkinsfile post-actions pushing report to Xray API
post {
    always {
        // Push the JSON report using cURL and Xray authentication
        sh """
            curl -H "Content-Type: multipart/form-data" \
                 -u admin:adminPassword \
                 -F "file=@target/cucumber-reports/report.json" \
                 https://jira.company.com/rest/raven/2.0/import/execution/cucumber
        """
    }
}

// ❌ Old Regex binding - complex, prone to grouping mistakes
@Given("^the user has (\\d+) items in their (cart|wishlist)$")
public void oldRegexStep(int itemCount, String listType) {}

// ✅ Modern Cucumber Expression - clean, readable, typesafe
@Given("the user has {int} items in their {string}")
public void modernExpressionStep(int itemCount, String listType) {}

// Dynamic tag routing inside Jenkinsfile pipeline
stage('Execute BDD Tests') {
    steps {
        script {
            // Determine tag based on git branch name
            String testTag = "@smoke"
            if (env.BRANCH_NAME == 'main') {
                testTag = "@regression"
            }
            
            // Execute Maven with dynamic tag routing
            sh "mvn test -Dcucumber.filter.tags='${testTag}' -Dthreads=4"
        }
    }
}