Why framework design enables scalability in Selenium Java - Automation Benefits in Action

Verify login functionality using a scalable test framework design

Preconditions (3)

Step 1: Open the login page URL

Step 2: Enter valid username in the username field

Step 3: Enter valid password in the password field

Step 4: Click the login button

Step 5: Verify that the user is redirected to the dashboard page

✅ Expected Result: User successfully logs in and dashboard page is displayed

Automation Requirements - Selenium WebDriver with Java using Page Object Model

Assertions Needed:

Verify current URL matches dashboard URL after login

Verify presence of dashboard welcome message element

Best Practices:

Use Page Object Model to separate page locators and actions

Use explicit waits to handle dynamic page elements

Use assertions from TestNG framework

Keep test data separate from test logic

Automated Solution

Selenium Java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import java.time.Duration;

// Page Object for Login Page
class LoginPage {
    private WebDriver driver;
    private WebDriverWait wait;

    private By usernameField = By.id("username");
    private By passwordField = By.id("password");
    private By loginButton = By.id("loginBtn");

    public LoginPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    }

    public void enterUsername(String username) {
        wait.until(ExpectedConditions.visibilityOfElementLocated(usernameField)).sendKeys(username);
    }

    public void enterPassword(String password) {
        wait.until(ExpectedConditions.visibilityOfElementLocated(passwordField)).sendKeys(password);
    }

    public void clickLogin() {
        wait.until(ExpectedConditions.elementToBeClickable(loginButton)).click();
    }
}

// Page Object for Dashboard Page
class DashboardPage {
    private WebDriver driver;
    private WebDriverWait wait;

    private By welcomeMessage = By.id("welcomeMsg");

    public DashboardPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    }

    public boolean isWelcomeMessageDisplayed() {
        return wait.until(ExpectedConditions.visibilityOfElementLocated(welcomeMessage)).isDisplayed();
    }
}

public class LoginTest {
    private WebDriver driver;
    private LoginPage loginPage;
    private DashboardPage dashboardPage;

    @BeforeClass
    public void setUp() {
        driver = new ChromeDriver();
        driver.manage().window().maximize();
        driver.get("https://example.com/login");
        loginPage = new LoginPage(driver);
        dashboardPage = new DashboardPage(driver);
    }

    @Test
    public void testValidLogin() {
        loginPage.enterUsername("validUser");
        loginPage.enterPassword("validPass123");
        loginPage.clickLogin();

        // Verify URL
        String expectedUrl = "https://example.com/dashboard";
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        wait.until(ExpectedConditions.urlToBe(expectedUrl));
        Assert.assertEquals(driver.getCurrentUrl(), expectedUrl, "URL after login should be dashboard URL");

        // Verify welcome message
        Assert.assertTrue(dashboardPage.isWelcomeMessageDisplayed(), "Welcome message should be visible on dashboard");
    }

    @AfterClass
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

This test uses the Page Object Model (POM) design pattern to separate page details from test logic, making the framework scalable and easy to maintain.

The LoginPage class contains locators and methods for interacting with the login page. The DashboardPage class contains methods to verify elements on the dashboard.

The test class LoginTest initializes the browser, opens the login page, performs login steps, and asserts the expected URL and presence of a welcome message.

Explicit waits ensure the test waits for elements or URL changes, avoiding flaky tests.

Assertions from TestNG verify the expected outcomes clearly.

This design allows easy addition of new tests or pages without changing existing code, enabling scalability.

Common Mistakes - 3 Pitfalls

Hardcoding locators directly in test methods

Using Thread.sleep() instead of explicit waits

Mixing test logic and UI interaction code

Bonus Challenge

Now add data-driven testing with 3 different sets of valid username and password combinations

Show Hint

Practice

1. Why does using a test framework help when your test suite grows larger?

easy

A. It automatically writes new tests without human input.

B. It makes tests run slower but more accurately.

C. It organizes code to make adding new tests easier and faster.

D. It removes the need for any test maintenance.

Solution

1. Step 1: Understand framework purpose

   A test framework structures code and resources to manage tests efficiently.

2. Step 2: Connect framework to scalability

   Organized code allows easy addition and modification of tests as the suite grows.

3. Final Answer:

   It organizes code to make adding new tests easier and faster. -> Option C

4. Quick Check:

   Framework = organized, scalable tests [OK]

Hint: Frameworks help organize code for easy test growth [OK]

Common Mistakes:

• Thinking frameworks slow down tests
• Believing frameworks remove all maintenance
• Assuming frameworks auto-generate tests

2. Which Java code snippet best shows a reusable method in a Selenium test framework?

easy

A. public void login(String user, String pass) { driver.findElement(By.id("user")).sendKeys(user); driver.findElement(By.id("pass")).sendKeys(pass); driver.findElement(By.id("loginBtn")).click(); }

B. driver.findElement(By.id("user")).sendKeys("admin"); driver.findElement(By.id("pass")).sendKeys("1234"); driver.findElement(By.id("loginBtn")).click();

C. int x = 5; int y = 10; int sum = x + y;

D. System.out.println("Test started");

Solution

1. Step 1: Identify reusable method

   public void login(String user, String pass) { driver.findElement(By.id("user")).sendKeys(user); driver.findElement(By.id("pass")).sendKeys(pass); driver.findElement(By.id("loginBtn")).click(); } defines a method with parameters to reuse login steps with different data.

2. Step 2: Compare other options

   The other options are either hardcoded steps or unrelated code, not reusable methods.

3. Final Answer:

   Reusable login method with parameters -> Option A

4. Quick Check:

   Reusable method = method with parameters [OK]

Hint: Look for methods with parameters for reuse [OK]

Common Mistakes:

• Choosing hardcoded steps as reusable
• Confusing unrelated code as framework code
• Ignoring method parameters

3. Given this code snippet in a Selenium framework:

public void openPage() { driver.get("https://example.com"); }
public void login(String user, String pass) {
  driver.findElement(By.id("user")).sendKeys(user);
  driver.findElement(By.id("pass")).sendKeys(pass);
  driver.findElement(By.id("loginBtn")).click();
}
openPage();
login("admin", "1234");

What is the main benefit of this design when adding more tests?

medium

A. You can reuse openPage and login methods in many tests without rewriting code.

B. Tests will run slower because of method calls.

C. You must rewrite the login steps for each test.

D. The code will fail because methods are called outside a class.

Solution

1. Step 1: Analyze method usage

   openPage and login methods encapsulate common actions for reuse.

2. Step 2: Understand scalability impact

   Reusing methods avoids rewriting code, making it easier to add new tests.

3. Final Answer:

   Reuse methods to avoid rewriting code -> Option A

4. Quick Check:

   Reusable methods = easier test addition [OK]

Hint: Reusable methods save rewriting steps [OK]

Common Mistakes:

• Thinking method calls slow tests significantly
• Believing code must be rewritten each time
• Confusing syntax errors with design benefits

4. You have this Selenium test code snippet:

public void login(String user, String pass) {
  driver.findElement(By.id("username")).sendKeys(user);
  driver.findElement(By.id("password")).sendKeys(pass);
  driver.findElement(By.id("loginBtn")).click();
}
login("admin", "1234");

But the test fails because elements are not found. What is the likely fix to improve framework scalability?

medium

A. Remove the login method and write steps inline.

B. Use a centralized locator repository to manage element locators.

C. Hardcode element locators inside each test method.

D. Ignore element locators and rely on implicit waits only.

Solution

1. Step 1: Identify problem cause

   Element locators scattered cause maintenance issues and test failures.

2. Step 2: Apply framework design principle

   Centralizing locators in one place improves maintainability and scalability.

3. Final Answer:

   Use centralized locator repository -> Option B

4. Quick Check:

   Centralized locators = easier updates [OK]

Hint: Centralize locators to fix element not found errors [OK]

Common Mistakes:

• Hardcoding locators everywhere
• Removing reusable methods
• Relying only on waits without fixing locators

5. In a Selenium Java framework, you want to add a new feature test that requires login and navigation. Which design approach best supports scalability?

hard

A. Write separate tests for login and navigation without combining them.

B. Copy-paste login and navigation steps directly into the new test method.

C. Write all test steps inline without methods to keep it simple.

D. Create reusable methods for login and navigation, then call them in the new test.

Solution

1. Step 1: Understand scalability needs

   Scalable frameworks use reusable methods to avoid duplication and ease maintenance.

2. Step 2: Apply reusable methods to new feature

   Creating reusable login and navigation methods allows easy updates and test growth.

3. Final Answer:

   Create reusable methods and call them in tests -> Option D

4. Quick Check:

   Reusable methods enable scalable test design [OK]

Hint: Use reusable methods to add new features easily [OK]

Common Mistakes:

• Copy-pasting code causing maintenance issues
• Writing all steps inline making tests long
• Separating related steps into different tests unnecessarily