Why CI integration enables continuous testing in Selenium Java - Automation Benefits in Action

Verify that the login functionality works correctly when integrated with CI

Preconditions (3)

Step 1: Open the login page URL

Step 2: Enter 'testuser' in the username field

Step 3: Enter 'Test@123' 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 with URL containing '/dashboard'

Automation Requirements - Selenium WebDriver with JUnit 5

Assertions Needed:

Verify the current URL contains '/dashboard' after login

Verify the login button is clickable before clicking

Verify username and password fields are present and enabled

Best Practices:

Use explicit waits to wait for elements to be clickable or visible

Use Page Object Model to separate page interactions

Use assertions from JUnit 5 for validation

Use meaningful element locators (id or name preferred)

Close the browser after test execution

Automated Solution

Selenium Java

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.assertTrue;
import java.time.Duration;

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

    @BeforeEach
    public void setUp() {
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        driver.get("https://example.com/login");
    }

    @Test
    public void testSuccessfulLogin() {
        WebElement usernameField = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));
        WebElement passwordField = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("password")));
        WebElement loginButton = wait.until(ExpectedConditions.elementToBeClickable(By.id("loginBtn")));

        usernameField.sendKeys("testuser");
        passwordField.sendKeys("Test@123");
        loginButton.click();

        wait.until(ExpectedConditions.urlContains("/dashboard"));
        String currentUrl = driver.getCurrentUrl();
        assertTrue(currentUrl.contains("/dashboard"), "URL should contain '/dashboard' after login");
    }

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

This test script uses Selenium WebDriver with JUnit 5 to automate the login test.

Setup: We open the browser and navigate to the login page before each test.

Test: We wait explicitly for username, password fields, and login button to be visible and clickable. Then we enter the credentials and click login.

We wait until the URL contains '/dashboard' to confirm successful login and assert this condition.

Teardown: We close the browser after the test to clean up.

This approach uses explicit waits to avoid timing issues and meaningful locators (id). It follows best practices for maintainable and reliable tests.

Common Mistakes - 3 Pitfalls

Using Thread.sleep() instead of explicit waits

Using brittle XPath locators that rely on full element paths

Not closing the browser after test execution

Bonus Challenge

Now add data-driven testing with 3 different sets of user credentials (valid and invalid) to verify login behavior.

Show Hint

Practice

1. What is the main benefit of integrating Continuous Integration (CI) with automated testing?

easy

A. Developers write tests manually after each release

B. Tests run automatically on every code change to catch bugs early

C. Tests are only run once before the final product launch

D. CI integration slows down the development process

Solution

1. Step 1: Understand CI integration purpose

   CI integration automates running tests whenever code changes are made.

2. Step 2: Identify the benefit of automation

   This automation helps find bugs early and reduces manual testing effort.

3. Final Answer:

   Tests run automatically on every code change to catch bugs early -> Option B

4. Quick Check:

   CI automation = early bug detection [OK]

Hint: CI runs tests on every change to catch bugs fast [OK]

Common Mistakes:

• Thinking tests run only at the end
• Believing CI slows development
• Assuming manual testing is always needed

2. Which of the following is the correct way to trigger a Selenium test in a CI pipeline using Java?

easy

A. Manually open the browser and run tests

B. Use java -jar selenium-server.jar without test classes

C. Run the test class with mvn test command

D. Write tests in Python and run with python test.py

Solution

1. Step 1: Identify standard Java test execution in CI

   Maven command mvn test runs Java Selenium tests automatically.

2. Step 2: Eliminate incorrect options

   Manual browser opening is not automated; running selenium-server alone doesn't run tests; Python command is unrelated to Java tests.

3. Final Answer:

   Run the test class with mvn test command -> Option C

4. Quick Check:

   Java tests run with mvn test [OK]

Hint: Use mvn test to run Java Selenium tests in CI [OK]

Common Mistakes:

• Confusing manual and automated test runs
• Using wrong commands for Java tests
• Mixing languages in CI commands

3. Given the following CI pipeline snippet triggering Selenium tests, what will happen if a test fails?

stage('Test') {
  steps {
    sh 'mvn test'
  }
}

medium

A. The pipeline will stop and mark the build as failed

B. The pipeline will ignore the failure and continue

C. The tests will rerun automatically until they pass

D. The pipeline will skip the test stage entirely

Solution

1. Step 1: Understand Maven test behavior in CI

   If any test fails, mvn test returns a failure exit code.

2. Step 2: Effect on CI pipeline

   CI pipelines stop on failure exit codes and mark the build as failed to alert developers.

3. Final Answer:

   The pipeline will stop and mark the build as failed -> Option A

4. Quick Check:

   Test failure = pipeline failure [OK]

Hint: Failed tests stop CI build immediately [OK]

Common Mistakes:

• Assuming tests auto-retry on failure
• Thinking pipeline ignores test failures
• Believing tests run without stopping pipeline

4. You integrated Selenium tests in your CI pipeline, but tests are not running after code commits. What is the most likely cause?

medium

A. The Selenium WebDriver is outdated but tests still run

B. Tests are passing too quickly to be noticed

C. The code commits are not triggering any build

D. The test stage is missing or not configured in the CI pipeline

Solution

1. Step 1: Check CI pipeline configuration

   If the test stage is missing or misconfigured, tests won't run after commits.

2. Step 2: Rule out other causes

   Passing tests still run; outdated WebDriver causes failures, not silence; commits usually trigger builds unless disabled.

3. Final Answer:

   The test stage is missing or not configured in the CI pipeline -> Option D

4. Quick Check:

   Missing test stage = no tests run [OK]

Hint: Verify test stage exists in CI config [OK]

Common Mistakes:

• Ignoring pipeline config errors
• Assuming tests run without pipeline setup
• Blaming WebDriver without errors

5. How does integrating Selenium tests into a CI pipeline improve software delivery speed and quality?

hard

A. By running tests automatically on every commit, catching bugs early and reducing manual testing delays

B. By requiring developers to manually trigger tests after each feature is complete

C. By running tests only once before the final release to save time

D. By replacing all manual testing with automated tests without human review

Solution

1. Step 1: Understand CI and Selenium test integration

   Automated tests run on every commit, providing quick feedback on code quality.

2. Step 2: Benefits of early bug detection and automation

   This reduces delays from manual testing and prevents bugs from reaching production.

3. Final Answer:

   By running tests automatically on every commit, catching bugs early and reducing manual testing delays -> Option A

4. Quick Check:

   Auto tests + early bugs = faster, better delivery [OK]

Hint: Auto tests on commits catch bugs early, speeding delivery [OK]

Common Mistakes:

• Thinking tests run only at release
• Believing manual triggers are needed
• Assuming automation removes all human checks