Playwright vs Old Tools: What Changed for Java Developers

Why Playwright's Architecture Matters:

1. No WebDriver Middleman
   • Selenium: Test → WebDriver → Browser
   • Playwright: Test → Browser (direct)

2. Result:
   • Faster execution
   • More reliable (no driver version issues)
   • Better handling of modern web apps

3. Auto-Waiting
   • Selenium: You write explicit waits
   • Playwright: Waits automatically for:
     - Elements to appear
     - Elements to be visible
     - Elements to be enabled

4. Trace Viewer
   • Records every action
   • Timeline view of test execution
   • Network logs, console logs, DOM snapshots

// Selenium — manual waits required
WebElement element = driver.findElement(By.id("submit"));
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.elementToBeClickable(element));
element.click();

// Playwright — auto-wait built-in
page.locator("#submit").click();
// Playwright waits for the element to be:
// - present
// - visible
// - enabled
// - stable (not animating)

Auto-Waiting in Playwright:

// Playwright automatically waits for:
// 1. Element to be attached to DOM
// 2. Element to be visible
// 3. Element to be stable (no animation)
// 4. Element to be enabled
// 5. Element to receive events

// This works out of the box:
page.locator("button.submit").click();

// No need for:
// - Thread.sleep()
// - WebDriverWait
// - ExpectedConditions

// For custom waits:
page.waitForSelector("button.submit", 
    new Page.WaitForSelectorOptions().setState("visible"));

Trace Viewer in Playwright:

// Enable tracing:
context.tracing().start(new Tracing.StartOptions()
    .setScreenshots(true)
    .setSnapshots(true));

// Run your test...

// Stop tracing:
context.tracing().stop(new Tracing.StopOptions()
    .setPath(Paths.get("trace.zip")));

// View trace:
// npx playwright show-trace trace.zip

// What you see:
// • Timeline of every action
// • Screenshots at each step
// • DOM snapshots
// • Network requests
// • Console logs
// • Source code location

Parallel Execution in Playwright:

// With JUnit 5, add this to junit-platform.properties:
// junit.jupiter.execution.parallel.enabled = true
// junit.jupiter.execution.parallel.mode.default = concurrent

// Playwright runs each test in a separate browser context:
@BeforeEach
void setUp() {
    browser = playwright.chromium().launch();
    context = browser.newContext();
    page = context.newPage();
}

// No Grid setup required
// Each test gets its own isolated browser context

// Selenium — old approach
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
WebElement username = driver.findElement(By.id("username"));
username.sendKeys("testuser");
WebElement password = driver.findElement(By.id("password"));
password.sendKeys("password123");
WebElement loginBtn = driver.findElement(By.id("login"));
WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.elementToBeClickable(loginBtn));
loginBtn.click();

// Playwright — new approach
Playwright playwright = Playwright.create();
Browser browser = playwright.chromium().launch();
Page page = browser.newPage();
page.navigate("https://example.com");
page.locator("#username").fill("testuser");
page.locator("#password").fill("password123");
page.locator("#login").click();
// Auto-waiting handles everything

Common Changes When Migrating:

1. Locators
   • Selenium: By.id(), By.xpath(), By.cssSelector()
   • Playwright: page.locator("#id"), page.getByRole(), 
     page.getByText()

2. Waits
   • Selenium: WebDriverWait, Thread.sleep()
   • Playwright: Auto-waiting (no explicit waits needed)

3. Actions
   • Selenium: sendKeys(), click()
   • Playwright: fill(), click(), check(), selectOption()

4. Browser Setup
   • Selenium: WebDriver per browser
   • Playwright: Playwright.create() + browserType().launch()

5. Assertions
   • Selenium: Assert.assertEquals()
   • Playwright: assertThat(locator).isVisible()

4-Week Playwright Learning Path (Java):

Week 1: Setup & Basics
• Add Playwright dependency to pom.xml
• Install browsers (playwright install)
• Write first test (navigate + assert)
• Run tests with Maven

Week 2: Locators & Auto-Waiting
• Learn getByRole, getByText, getByLabel
• Understand auto-waiting
• Handle dynamic content
• Practice with forms and tables

Week 3: Page Objects & Parallel
• Create Page Objects
• Set up JUnit 5 parallel execution
• Test data management
• Build a real test suite

Week 4: CI/CD & Debugging
• Integrate with GitHub Actions
• Use Trace Viewer
• Set up screenshots on failure
• Run tests in Docker

Resources for Learning Playwright:

Official:
• playwright.dev/java — official docs
• Playwright GitHub — examples

Free:
• YouTube: Playwright Java tutorials
• freeCodeCamp: Playwright crash course
• Uncodemy blog: Playwright guides

Practice:
• Automate a demo site (saucedemo.com)
• Build tests for your own project
• Contribute to open-source testing

Communities:
• Playwright Discord
• Stack Overflow (playwright tag)
• Reddit r/QualityAssurance