Complete Guide to Integrating Cucumber, Playwright, and TestNG in Java (Step-by-Step Tutorial)

Modern test automation frameworks demand speed, scalability, readability, and maintainability. If you are working in automation testing or preparing for SDET roles, integrating Cucumber, Playwright, and TestNG in Java is one of the most powerful combinations you can learn today.
This detailed, fully SEO-optimized and AdSense-friendly guide explains:
What is Cucumber, Playwright, and TestNG?
Role of each tool in automation
How integration works step-by-step
Complete Maven configuration
Feature file implementation
Step definitions with Playwright
TestNG runner configuration
Parallel execution setup
Benefits of this integration
Real-time project structure
By the end of this guide, you will clearly understand how to build a professional BDD automation framework using Java.

What is Cucumber, Playwright, and TestNG Integration?

Integrating Cucumber, Playwright, and TestNG in Java enables you to:
Write BDD-style test cases using Gherkin (.feature files)
Automate browser actions using Playwright
Manage execution using TestNG
Generate structured and readable reports
This combination is widely used in enterprise-level automation frameworks because it ensures:
Clean architecture
Collaboration between business and QA teams
Cross-browser testing
Parallel execution support
Advanced reporting capabilities

Role of Each Component in the Framework

Let’s understand the purpose of each tool clearly.

1. Playwright – The Browser Automation Engine

Playwright is a modern browser automation framework that supports:
Chromium
Firefox
WebKit
Playwright is responsible for:
Launching browsers
Navigating web pages
Clicking elements
Entering text
Handling alerts
Capturing screenshots
Validating UI elements
Performing cross-browser testing
It provides fast and reliable execution with auto-waiting features and modern selector strategies.
In simple words:
👉 Playwright performs actual browser operations.

2. Cucumber – The BDD Framework

Cucumber is a Behavior-Driven Development (BDD) framework that allows writing test scenarios in Gherkin language.

Gherkin format:

Given
When
Then
And
But

Example:


Given user launches the browser
When user logs in with valid credentials
Then homepage should be displayed

Benefits of Cucumber:

Makes test cases readable
Bridges gap between business and technical teams
Allows non-technical stakeholders to understand test scenarios
Encourages collaboration

In simple words:

👉 Cucumber defines what needs to be tested in plain English.

3. TestNG – The Test Execution Framework

TestNG is a powerful Java testing framework that provides:
Test configuration
Annotations (@Before, @After, etc.)
Parallel execution
Grouping tests
Data-driven testing
Detailed reporting
Retry mechanisms
TestNG controls:
How tests run
In what order they run
Whether they run in parallel
How reports are generated
In simple words:
👉 TestNG manages execution and reporting.

How Cucumber + Playwright + TestNG Integration Works

Let’s understand the flow step-by-step.

Step 1: Cucumber Defines Test Scenarios

Business or QA teams write scenarios inside feature files using Gherkin syntax.

Example:


Feature: Check title

Scenario: Open login page and check title
Given I launch the application
Then I should see the page title as "Example Domain"

These feature files describe expected behavior.

Step 2: Step Definitions Use Playwright

Each Gherkin step is mapped to a Java method called Step Definition.
Inside these step definitions:
Playwright APIs are used.
Browser actions are performed.
Assertions validate results.
For example:
page.navigate()
page.title()
page.click()
Playwright executes real browser interactions.

Step 3: TestNG Executes Scenarios

TestNG acts as the test runner.
It:
Executes Cucumber feature files
Controls parallel execution
Generates execution reports
Integrates with Maven
TestNG can run scenarios in parallel using DataProvider.

Step 4: Unified Reporting

After execution:
Cucumber generates BDD-style reports.
TestNG generates execution reports (HTML/XML).
Reports can be integrated with advanced tools like Allure or Extent Reports.
This ensures:
Business-friendly reports
Developer-friendly logs

Tools Used in This Framework

Cucumber for BDD feature files
Playwright for Java for browser automation
TestNG for execution and reporting
Maven for dependency management
Website to be automated:
https://example.com

Step-by-Step Integration Setup

Let’s implement a simple example that verifies the title of https://example.com.

1. pom.xml Configuration

The pom.xml file manages project dependencies.


<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>cucumber-playwright-testng</artifactId>
  <version>1.0</version>

  <dependencies>
    <!-- Cucumber Dependencies -->
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-java</artifactId>
      <version>7.14.0</version>
    </dependency>
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-testng</artifactId>
      <version>7.14.0</version>
    </dependency>

    <!-- TestNG -->
    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>7.9.0</version>
      <scope>test</scope>
    </dependency>

    <!-- Playwright Java -->
    <dependency>
      <groupId>com.microsoft.playwright</groupId>
      <artifactId>playwright</artifactId>
      <version>1.44.0</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.2.5</version>
        <configuration>
          <suiteXmlFiles>
            <suiteXmlFile>testng.xml</suiteXmlFile>
          </suiteXmlFiles>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

This configuration connects all tools together.

2. Feature File (Title.feature)

Location:

src/test/resources/features/Title.feature


Feature: Check title

  Scenario: Open login page and check title
    Given I launch the application
    Then I should see the page title as "Example Domain"

This describes expected behavior in simple English.

3. PlaywrightFactory.java

This utility class manages:

Playwright object
Browser instance
Page instance
Initialization
Cleanup


package utils;

import com.microsoft.playwright.*;

public class PlaywrightFactory {
    public static Playwright playwright;
    public static Browser browser;
    public static Page page;

    public static void init() {
        playwright = Playwright.create();
        browser = playwright.chromium().launch(
            new BrowserType.LaunchOptions().setHeadless(false)
        );
        page = browser.newPage();
    }

    public static void close() {
        browser.close();
        playwright.close();
    }
}

Why use a factory class?

Avoid duplicate code
Centralize browser management
Improve maintainability

4. Step Definition Class (LoginSteps.java)

This class connects feature steps to Playwright actions.


package steps;

import com.microsoft.playwright.Page;
import io.cucumber.java.After;
import io.cucumber.java.Before;
import io.cucumber.java.en.*;
import utils.PlaywrightFactory;

import static org.testng.Assert.assertEquals;

public class LoginSteps {
    Page page;

    @Before
    public void setup() {
        PlaywrightFactory.init();
        page = PlaywrightFactory.page;
    }

    @Given("I launch the application")
    public void i_launch_the_application() {
        page.navigate("https://example.com");
    }

    @Then("I should see the page title as {string}")
    public void i_should_see_the_page_title_as(String expectedTitle) {
        String actualTitle = page.title();
        assertEquals(actualTitle, expectedTitle);
    }

    @After
    public void tearDown() {
        PlaywrightFactory.close();
    }
}

Execution flow:

@Before initializes browser
Given step navigates to site
Then step validates title
@After closes browser

5. TestRunner.java (Cucumber + TestNG Runner)


package runners;

import io.cucumber.testng.AbstractTestNGCucumberTests;
import io.cucumber.testng.CucumberOptions;
import org.testng.annotations.DataProvider;

@CucumberOptions(
    features = "src/test/resources/features",
    glue = "steps",
    plugin = {"pretty", "html:target/cucumber-reports.html"},
    monochrome = true
)
public class TestRunner extends AbstractTestNGCucumberTests {

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

Important points:

features → Location of feature files
glue → Location of step definitions
plugin → Reporting configuration
DataProvider(parallel = true) → Enables parallel execution

6. testng.xml (Optional Suite Execution)


<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="Cucumber Playwright TestNG Suite">
  <test name="Cucumber Tests">
    <classes>
      <class name="runners.TestRunner"/>
    </classes>
  </test>
</suite>

This file allows suite-level control and execution.

Advantages of This Integration

1. Readable Test Scenarios

Cucumber makes scenarios easy to understand.

2. Powerful Browser Automation

Playwright ensures fast and reliable execution.

3. Parallel Execution

TestNG allows parallel execution for faster test cycles.

4. Scalability

This framework works well for:
Large enterprise projects
Continuous Integration pipelines
Multi-browser testing

5. Flexible Reporting

Both:
BDD reports
Technical execution reports
are generated.

Best Practices for Enterprise Projects

Use Page Object Model (POM)
Avoid hardcoded URLs
Store configurations in properties file
Use proper logging
Implement retry logic
Integrate with CI/CD tools

Conclusion

Integrating Cucumber, Playwright, and TestNG in Java creates a powerful, scalable, and maintainable automation framework.
Cucumber provides readability.
Playwright provides modern browser automation.
TestNG provides execution control and reporting.
This combination is ideal for:
Automation testers
SDET engineers
QA leads
Enterprise automation frameworks
If you are building a real-world automation project, this integration is highly recommended.

Integration of Playwright, Cucumber, and TestNG