Why patterns improve test quality in JUnit - Automation Benefits in Action

Automate login functionality using Page Object pattern

Preconditions (2)

Step 1: Open the login page URL

Step 2: Enter '[e-mail]' in the email input field

Step 3: Enter 'Password123' in the password input field

Step 4: Click the login button

Step 5: Verify that the user is redirected to the dashboard page with URL containing '/dashboard'

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

Automation Requirements - JUnit 5 with Selenium WebDriver

Assertions Needed:

Verify current URL contains '/dashboard' after login

Verify login button is clickable before clicking

Best Practices:

Use Page Object Model to separate page structure from test logic

Use explicit waits to wait for elements to be ready

Use meaningful assertions with clear messages

Automated Solution

JUnit

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
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 static org.junit.jupiter.api.Assertions.*;
import java.time.Duration;

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

    private By emailField = By.id("email");
    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 open() {
        driver.get("http://example.com/login");
    }

    public void enterEmail(String email) {
        WebElement emailInput = wait.until(ExpectedConditions.visibilityOfElementLocated(emailField));
        emailInput.clear();
        emailInput.sendKeys(email);
    }

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

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

public class LoginTest {
    private WebDriver driver;
    private WebDriverWait wait;
    private LoginPage loginPage;

    @BeforeEach
    public void setUp() {
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        loginPage = new LoginPage(driver);
    }

    @Test
    public void testSuccessfulLogin() {
        loginPage.open();
        loginPage.enterEmail("[e-mail]");
        loginPage.enterPassword("Password123");
        loginPage.clickLogin();

        // Wait for URL to contain /dashboard
        boolean urlContainsDashboard = wait.until(ExpectedConditions.urlContains("/dashboard"));
        assertTrue(urlContainsDashboard, "URL should contain '/dashboard' after login");
    }

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

This test uses the Page Object Model pattern to separate the login page details from the test logic. The LoginPage class contains methods to interact with the login page elements. This makes the test easier to read and maintain.

Explicit waits ensure elements are ready before interacting, avoiding flaky tests. Assertions check that after login, the URL contains '/dashboard', confirming successful login.

The setup and teardown methods initialize and close the browser cleanly for each test run.

Common Mistakes - 3 Pitfalls

Hardcoding element locators directly in the test method

Using Thread.sleep() instead of explicit waits

Not verifying element is clickable before clicking

Bonus Challenge

Now add data-driven testing with 3 different sets of login credentials (valid and invalid)

Show Hint

Practice

1. Why do test patterns improve the quality of JUnit tests?

easy

A. They remove the need for assertions

B. They increase the runtime of tests significantly

C. They make tests easier to read and maintain

D. They automatically fix bugs in the code

Solution

1. Step 1: Understand the purpose of test patterns

   Test patterns organize test code to be clear and structured.

2. Step 2: Connect patterns to test quality

   Clear and maintainable tests help developers understand and update tests easily, improving quality.

3. Final Answer:

   They make tests easier to read and maintain -> Option C

4. Quick Check:

   Patterns improve readability = A [OK]

Hint: Patterns improve readability and maintenance [OK]

Common Mistakes:

• Thinking patterns increase test runtime
• Believing patterns remove assertions
• Assuming patterns fix bugs automatically

2. Which JUnit annotation is commonly used to apply the 'Arrange-Act-Assert' pattern in tests?

easy

A. @BeforeEach

B. @Test

C. @AfterAll

D. @Disabled

Solution

1. Step 1: Identify the annotation that marks test methods

   @Test marks the method where Arrange-Act-Assert steps happen.

2. Step 2: Understand other annotations' roles

   @BeforeEach runs setup before each test, @AfterAll runs after all tests, @Disabled skips tests.

3. Final Answer:

   @Test -> Option B

4. Quick Check:

   Test method annotation = D [OK]

Hint: Use @Test for main test steps [OK]

Common Mistakes:

• Confusing @BeforeEach with test method annotation
• Using @AfterAll for test logic
• Thinking @Disabled runs tests

3. Consider this JUnit test snippet using the 'Arrange-Act-Assert' pattern:

int result = calculator.add(2, 3);
assertEquals(5, result);

What will happen if the method add returns 4 instead of 5?

medium

A. The test will fail with an assertion error

B. The test will pass successfully

C. The test will throw a compilation error

D. The test will be skipped automatically

Solution

1. Step 1: Understand the assertion

   assertEquals(5, result) expects result to be 5.

2. Step 2: Analyze the returned value

   If add returns 4, the assertion fails because 4 != 5.

3. Final Answer:

   The test will fail with an assertion error -> Option A

4. Quick Check:

   Wrong result causes assertion failure = A [OK]

Hint: Assertion expects exact value; mismatch fails test [OK]

Common Mistakes:

• Assuming test passes with wrong result
• Thinking compilation error occurs
• Believing test skips on failure

4. This JUnit test uses a pattern but has an error:

@Test
public void testDivide() {
  int result = calculator.divide(10, 0);
  assertEquals(0, result);
}

What is the main problem here?

medium

A. Missing @BeforeEach annotation causes setup failure

B. assertEquals expects wrong value, test will pass incorrectly

C. Test method name is invalid

D. Division by zero causes an exception, test will error

Solution

1. Step 1: Identify the operation causing error

   Dividing by zero throws an exception in Java.

2. Step 2: Understand test behavior on exception

   Test will error because exception is not caught or expected.

3. Final Answer:

   Division by zero causes an exception, test will error -> Option D

4. Quick Check:

   Divide by zero throws exception = C [OK]

Hint: Division by zero throws error, not returns zero [OK]

Common Mistakes:

• Assuming test passes with zero result
• Thinking missing @BeforeEach causes error here
• Believing method name affects test execution

5. You want to improve your JUnit tests by applying the 'Arrange-Act-Assert' pattern consistently. Which approach best improves test quality?

hard

A. Separate setup, execution, and verification clearly in each @Test method

B. Write all test logic inside @BeforeEach methods

C. Use multiple assertions in @AfterAll methods

D. Avoid using assertions to speed up tests

Solution

1. Step 1: Understand the 'Arrange-Act-Assert' pattern

   This pattern divides tests into setup (Arrange), action (Act), and checks (Assert) within the test method.

2. Step 2: Identify best practice for test quality

   Keeping these steps clear inside each @Test method improves readability and debugging.

3. Final Answer:

   Separate setup, execution, and verification clearly in each @Test method -> Option A

4. Quick Check:

   Clear step separation in tests = B [OK]

Hint: Keep Arrange, Act, Assert steps clear inside @Test [OK]

Common Mistakes:

• Putting all logic in @BeforeEach
• Using assertions outside test methods
• Skipping assertions to save time