Showing posts with label Login Page Automation. Show all posts

How to Automate a Login Page by Playwright Java

How to Automate Login Page Using Playwright in Java (Complete Step-by-Step Guide)

Automating a login page is one of the most common and important tasks in test automation. Almost every web application starts with authentication, and ensuring that the login functionality works correctly is critical for application security and user experience.

In this detailed, SEO-optimized, AdSense-friendly guide, you will learn how to automate a login page using Playwright in Java, understand the conceptual workflow, and implement a real working example using the OrangeHRM demo website.

We will cover:

What is Playwright?
Why automate login functionality?
Step-by-step conceptual flow of login automation
Maven setup for Playwright Java
Complete Java code example
Code explanation in detail
Best practices for real-world projects
Positive and negative test validation strategies
Session handling and security considerations

Let’s begin.

What is Playwright?

Playwright is a modern, open-source automation framework developed by Microsoft. It allows you to automate:

Chromium (Chrome, Edge)
Firefox
WebKit (Safari engine)

Playwright supports multiple programming languages including Java, JavaScript, Python, and C#.

Key advantages of Playwright:

Auto-waiting mechanism
Fast execution
Built-in cross-browser support
Headless and headed execution
Network interception
API automation support
Powerful selectors

For Java automation engineers, Playwright provides a clean and robust API to simulate real user actions.

Why Automate a Login Page?

The login functionality is the entry point to most applications. Automating login ensures:

Credentials validation works properly
Role-based access is verified
Security messages appear correctly
Navigation to dashboard is successful
Application handles invalid login attempts properly

Website Used for Automation

In this guide, we will automate the login page of the OrangeHRM demo application:

https://opensource-demo.orangehrmlive.com/web/index.php/auth/login

This demo website is widely used for automation practice and supports login with the following credentials:

Username: Admin
Password: admin123

Conceptual Flow of Login Automation in Playwright

When automating login using Playwright in Java, the process replicates the exact steps a real user performs.

Let’s understand the complete workflow conceptually.

1. Test Preparation

Launch Browser

First, Playwright launches a browser instance (Chromium, Firefox, or WebKit).

Create Browser Context

A browser context is like an isolated session (similar to incognito mode). It ensures:

No session overlap
Clean environment for each test
Independent cookies and storage

Create a Page

A Page represents a single browser tab where automation steps are executed.

2. Navigate to Login Page

The browser is directed to the login URL.

Playwright automatically waits for page load, but explicit waits can be added if required.

3. Interact with Input Fields

This involves:

Locating the username field
Locating the password field
Entering credentials using page.fill()

Selectors can be:

ID
Name
CSS
XPath
Placeholder
Role-based

4. Click Login Button

Once credentials are entered:

Locate the login button
Perform click action
Wait for navigation or page update

Playwright ensures the element is visible and actionable before clicking.

5. Handle Synchronization

After clicking login:

Application may redirect to dashboard
Page content changes dynamically

Playwright automatically waits for navigation events, but explicit waits like waitForSelector() can be used to ensure stability.

6. Validate Login

Positive Scenario

Verify a unique element on the dashboard such as:

Profile icon
Welcome message
Logout button
Dashboard heading

If visible → Login successful.

Negative Scenario

Enter incorrect credentials and verify:

Error message displayed
User remains on login page
Proper validation message appears

7. Security & Session Handling

Playwright allows:

Capturing cookies
Storing session storage
Reusing authentication state

Browser context ensures isolation so multiple tests do not share sessions.

8. Tear Down

After test execution:

Close page
Close browser context
Close browser

This ensures:

No memory leaks
Clean test environment
Stable execution

Step-by-Step Implementation

Now let’s implement login automation using Playwright Java.

Step 1: Add Maven Dependency

Add the following dependency in your pom.xml file:


<dependencies>
    <dependency>
        <groupId>com.microsoft.playwright</groupId>
        <artifactId>playwright</artifactId>
        <version>1.44.0</version>
    </dependency>
</dependencies>

After adding dependency, run:


mvn install

Also install browsers:


mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="install"

Step 2: Java Code to Automate Login

Below is the complete working code:


import com.microsoft.playwright.*;

public class OrangeHRMLoginTest {
    public static void main(String[] args) {

        // Step 1: Launch Playwright
        try (Playwright playwright = Playwright.create()) {

            // Step 2: Launch a browser (Chromium)
            Browser browser = playwright.chromium()
                    .launch(new BrowserType.LaunchOptions().setHeadless(false));

            // Step 3: Create a new browser context
            BrowserContext context = browser.newContext();

            // Step 4: Open a new page
            Page page = context.newPage();

            // Step 5: Navigate to the login page
            page.navigate("https://opensource-demo.orangehrmlive.com/web/index.php/auth/login");

            // Step 6: Wait for username field
            page.waitForSelector("input[name='username']");

            // Step 7: Fill login credentials
            page.fill("input[name='username']", "Admin");
            page.fill("input[name='password']", "admin123");

            // Step 8: Click login button
            page.click("button[type='submit']");

            // Step 9: Wait for dashboard
            page.waitForSelector("h6.oxd-topbar-header-breadcrumb-module");

            System.out.println("Login successful!");

            // Step 10: Close browser
            browser.close();
        }
    }
}

Code Explanation (Detailed Breakdown)

Line/Block	Explanation
Playwright.create()	Starts Playwright engine
chromium().launch()	Launches Chromium browser
setHeadless(false)	Opens browser in visible mode
browser.newContext()	Creates isolated browser session
context.newPage()	Opens new browser tab
page.navigate(url)	Opens login page URL
waitForSelector()	Waits until element is visible
page.fill()	Enters text into input field
page.click()	Clicks login button
browser.close()	Closes browser

Required Credentials

For OrangeHRM demo:

Username: Admin
Password: admin123

Best Practices for Real-World Login Automation

To make your automation more stable and professional:

1. Avoid Hardcoding Credentials

Store credentials in:

Environment variables
Config file
Properties file

2. Use Explicit Assertions

Instead of just printing success message, validate:


if (page.isVisible("h6.oxd-topbar-header-breadcrumb-module")) {
    System.out.println("Login verified successfully");
}

3. Use Page Object Model (POM)

Create separate LoginPage class:

Define locators
Define login() method

This improves maintainability.

4. Add Negative Test Case

Test invalid login:


page.fill("input[name='username']", "WrongUser");
page.fill("input[name='password']", "WrongPass");
page.click("button[type='submit']");
page.waitForSelector(".oxd-alert-content-text");

Validate error message.

5. Use Headless Mode for CI/CD

For pipeline execution:


.setHeadless(true)

This improves speed and performance.

Handling Synchronization Properly

Although Playwright auto-waits:

Always wait for navigation when necessary
Use waitForSelector() for dynamic elements
Avoid Thread.sleep()

Proper synchronization ensures stable tests.

Security & Session Reuse

Playwright allows:

Saving storage state
Reusing authentication

Example:


context.storageState(new BrowserContext.StorageStateOptions().setPath("auth.json"));

This avoids repeated login in multiple tests.

Advantages of Using Playwright for Login Automation

Faster than Selenium
Auto-waiting built-in
Supports modern web apps
Easy API
Parallel execution support
Cross-browser testing

When to Integrate with Test Frameworks?

For enterprise projects, integrate with:

TestNG
JUnit
Cucumber (BDD)

This enables:

Reporting
Parallel execution
Suite management
CI/CD integration

Conclusion

Automating a login page using Playwright in Java is straightforward yet powerful. By simulating real user actions such as entering credentials and clicking login, you can verify authentication workflows effectively.

In this guide, we covered:

Conceptual flow of login automation
Maven setup
Complete Java implementation
Code explanation
Best practices
Positive and negative scenarios
Security and session handling

If you are building an automation framework, mastering login automation is the first and most important step.