Jenkins pipeline integration in Selenium Java - Build an Automation Script

Automate login test and integrate with Jenkins pipeline

Preconditions (3)

Step 1: Open browser and navigate to 'https://example.com/login'

Step 2: Enter 'testuser' in username field with id 'username'

Step 3: Enter 'Test@1234' in password field with id 'password'

Step 4: Click on login button with id 'loginBtn'

Step 5: Verify that the URL changes to 'https://example.com/dashboard'

Step 6: Verify that an element with id 'welcomeMessage' is displayed

✅ Expected Result: User is successfully logged in, dashboard page is displayed with welcome message visible

Automation Requirements - Selenium WebDriver with TestNG

Assertions Needed:

Verify current URL is 'https://example.com/dashboard'

Verify welcome message element is displayed

Best Practices:

Use Page Object Model to separate page locators and actions

Use explicit waits to wait for elements

Use TestNG annotations for setup and teardown

Use Jenkins pipeline to run tests automatically on code commit

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;

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

    @BeforeClass
    public void setUp() {
        // Set path to chromedriver executable if needed
        // System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        driver.manage().window().maximize();
    }

    @Test
    public void testLogin() {
        driver.get("https://example.com/login");

        WebElement usernameInput = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));
        usernameInput.sendKeys("testuser");

        WebElement passwordInput = driver.findElement(By.id("password"));
        passwordInput.sendKeys("Test@1234");

        WebElement loginButton = driver.findElement(By.id("loginBtn"));
        loginButton.click();

        // Wait for URL to change to dashboard
        wait.until(ExpectedConditions.urlToBe("https://example.com/dashboard"));
        Assert.assertEquals(driver.getCurrentUrl(), "https://example.com/dashboard", "URL after login should be dashboard");

        WebElement welcomeMessage = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("welcomeMessage")));
        Assert.assertTrue(welcomeMessage.isDisplayed(), "Welcome message should be visible on dashboard");
    }

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

// Jenkins pipeline snippet (Jenkinsfile) to run this test:
// pipeline {
//   agent any
//   stages {
//     stage('Checkout') {
//       steps {
//         checkout scm
//       }
//     }
//     stage('Build and Test') {
//       steps {
//         sh './mvnw clean test'
//       }
//     }
//   }
// }

This Java test uses Selenium WebDriver with TestNG to automate the login test.

setUp() initializes the Chrome browser and sets an explicit wait.

testLogin() opens the login page, enters username and password, clicks login, then waits for the dashboard URL and welcome message to appear. Assertions verify the URL and element visibility.

tearDown() closes the browser after tests.

The Jenkins pipeline snippet shows how to run the Maven test command automatically on Jenkins after code checkout.

This structure follows best practices: explicit waits avoid flaky tests, TestNG manages test lifecycle, and the pipeline automates running tests on code changes.

Common Mistakes - 4 Pitfalls

Using Thread.sleep() instead of explicit waits

Hardcoding XPath locators that are brittle

Not closing the browser after tests

Mixing test logic and page locators in the same class

Bonus Challenge

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

Show Hint

Practice

1. What is the main purpose of integrating Selenium Java tests into a Jenkins pipeline?

easy

A. To automate running tests and catch issues early

B. To manually trigger tests only when needed

C. To write Selenium tests inside Jenkins scripts

D. To replace Selenium with Jenkins for testing

Solution

1. Step 1: Understand Jenkins pipeline role

   Jenkins pipelines automate tasks like building and testing software continuously.

2. Step 2: Identify Selenium test integration benefit

   Integrating Selenium tests in Jenkins runs tests automatically to find problems early.

3. Final Answer:

   To automate running tests and catch issues early -> Option A

4. Quick Check:

   Automation + early detection = A [OK]

Hint: Jenkins pipelines run tests automatically to find bugs early [OK]

Common Mistakes:

• Thinking Jenkins replaces Selenium tests
• Believing tests run only manually
• Confusing Jenkins with test writing tool

2. Which Jenkinsfile syntax correctly defines a stage named 'Test' that runs Selenium tests using Maven?

easy

A. stage: 'Test' { steps: { sh 'mvn test' } }

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

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

D. stage('Test') { run 'mvn test' }

Solution

1. Step 1: Recall Jenkins declarative syntax

   Stages use the format stage('name') { steps { ... } } to define actions.

2. Step 2: Check each option's syntax

   stage('Test') { steps { sh 'mvn test' } } matches correct syntax; others have wrong punctuation or keywords.

3. Final Answer:

   stage('Test') { steps { sh 'mvn test' } } -> Option C

4. Quick Check:

   Correct stage block syntax = B [OK]

Hint: Use stage('name') { steps { ... } } for Jenkins pipeline stages [OK]

Common Mistakes:

• Using colons instead of braces
• Omitting steps block
• Using 'run' instead of 'sh' for shell commands

3. Given this Jenkins pipeline snippet, what will be the output if Maven tests fail?

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'mvn clean compile'
      }
    }
    stage('Test') {
      steps {
        sh 'mvn test'
      }
    }
  }
}

medium

A. Pipeline continues to next stage ignoring test failure

B. Pipeline stops and marks build as failed

C. Pipeline retries the test stage automatically

D. Pipeline marks build as successful despite failure

Solution

1. Step 1: Understand default Jenkins pipeline behavior

   By default, if a shell command fails (non-zero exit), Jenkins stops and marks build failed.

2. Step 2: Apply this to Maven test failure

   Since 'mvn test' fails, the pipeline stops and build is marked failed.

3. Final Answer:

   Pipeline stops and marks build as failed -> Option B

4. Quick Check:

   Failing shell command stops pipeline = A [OK]

Hint: Failed shell commands stop Jenkins pipeline by default [OK]

Common Mistakes:

• Assuming pipeline continues after failure
• Thinking Jenkins retries automatically
• Believing build is marked successful on failure

4. You wrote this Jenkins pipeline snippet but tests never run:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'mvn clean compile'
      }
    }
    stage('Test') {
      sh 'mvn test'
    }
  }
}

What is the error?

medium

A. Missing steps block inside 'Test' stage

B. Wrong agent declaration

C. Maven command syntax is incorrect

D. Pipeline missing post section

Solution

1. Step 1: Check 'Test' stage structure

   Each stage must have a steps block wrapping commands; 'Test' stage lacks it.

2. Step 2: Identify impact of missing steps block

   Without steps block, Jenkins ignores commands inside the stage, so tests don't run.

3. Final Answer:

   Missing steps block inside 'Test' stage -> Option A

4. Quick Check:

   Every stage needs steps block = C [OK]

Hint: Always wrap commands inside steps { } in Jenkins stages [OK]

Common Mistakes:

• Omitting steps block in stages
• Confusing agent syntax
• Thinking post section runs tests

5. How can you modify a Jenkins pipeline to run Selenium Java tests only if the build stage succeeds, and always archive test reports regardless of test results?

hard

A. Use 'when' condition to skip archiving if tests fail

B. Run tests in parallel with build stage and archive in 'failure' block

C. Skip build stage and run tests directly, archive in 'success' block

D. Use 'post' block with 'always' to archive reports and normal stages for build and test

Solution

1. Step 1: Ensure test stage runs after successful build

   By default, stages run sequentially; test stage runs only if build succeeds.

2. Step 2: Use 'post' block with 'always' to archive reports

   The 'post' block with 'always' runs regardless of test success or failure, ensuring reports are archived.

3. Final Answer:

   Use 'post' block with 'always' to archive reports and normal stages for build and test -> Option D

4. Quick Check:

   Sequential stages + post always archive = D [OK]

Hint: Use post { always { ... } } to archive reports every run [OK]

Common Mistakes:

• Running tests in parallel with build
• Archiving only on success or failure
• Skipping build stage before tests