Custom annotations in Selenium Java - Build an Automation Script

Automate login test using custom annotation for test metadata

Preconditions (2)

Step 1: Navigate to the login page URL

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

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

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

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

Step 6: Verify that a welcome message with id 'welcomeMsg' is displayed

✅ Expected Result: User is successfully logged in and redirected to the dashboard page with welcome message visible

Automation Requirements - Selenium 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 elements and actions

Use explicit waits to wait for elements or URL changes

Create a custom annotation to add metadata to the test method (e.g., @TestInfo)

Use the custom annotation to store test case ID and description

Use TestNG assertions for validation

Automated Solution

Selenium Java

package tests;

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.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.time.Duration;

// Custom annotation definition
@Retention(RetentionPolicy.RUNTIME)
@interface TestInfo {
    String testCaseId();
    String description();
}

// 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 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();
    }
}

// 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();
        loginPage = new LoginPage(driver);
        dashboardPage = new DashboardPage(driver);
    }

    @Test
    @TestInfo(testCaseId = "TC001", description = "Verify successful login redirects to dashboard")
    public void testSuccessfulLogin() {
        driver.get("https://example.com/login");

        loginPage.enterEmail("[e-mail]");
        loginPage.enterPassword("Password123");
        loginPage.clickLogin();

        // Wait for URL to change to dashboard
        new WebDriverWait(driver, Duration.ofSeconds(10))
            .until(ExpectedConditions.urlToBe("https://example.com/dashboard"));

        Assert.assertEquals(driver.getCurrentUrl(), "https://example.com/dashboard", "URL should be dashboard URL after login");
        Assert.assertTrue(dashboardPage.isWelcomeMessageDisplayed(), "Welcome message should be visible on dashboard");
    }

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

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

We define a @TestInfo custom annotation to add metadata like test case ID and description to the test method. This helps organize and document tests clearly.

The Page Object Model is used to separate page elements and actions for the login and dashboard pages. This makes the code cleaner and easier to maintain.

Explicit waits ensure the test waits for elements to be visible or clickable before interacting, avoiding flaky tests.

The test method navigates to the login page, enters credentials, clicks login, then waits for the URL to change to the dashboard URL. It asserts the URL and checks that the welcome message is displayed.

Finally, the @AfterClass method closes the browser to clean up.

Common Mistakes - 5 Pitfalls

Not using explicit waits and relying on Thread.sleep

Hardcoding locators with brittle XPath expressions

Not separating page elements and actions into Page Objects

Not using custom annotations for test metadata

Not quitting the WebDriver after tests

Bonus Challenge

Now add data-driven testing with 3 different sets of login credentials using TestNG data provider

Show Hint

Practice

1. What is the main purpose of creating custom annotations in Selenium Java tests?

easy

A. To automatically generate test reports without any code

B. To replace all Selenium WebDriver methods with custom ones

C. To write test cases without using any Java code

D. To add metadata that can control test behavior or provide extra information

Solution

1. Step 1: Understand what annotations do

   Annotations add metadata to code elements like methods or classes, influencing how tests run or are processed.

2. Step 2: Identify the role of custom annotations

   Custom annotations let testers add their own metadata to control or describe tests beyond built-in annotations.

3. Final Answer:

   To add metadata that can control test behavior or provide extra information -> Option D

4. Quick Check:

   Custom annotations = metadata control [OK]

Hint: Custom annotations add info to tests, not replace code [OK]

Common Mistakes:

• Thinking custom annotations replace WebDriver methods
• Assuming they auto-generate reports without code
• Believing tests can run without Java code

2. Which of the following is the correct syntax to define a custom annotation named TestInfo in Java?

easy

A. public @interface TestInfo { String author(); int priority() default 1; }

B. public class TestInfo { String author(); int priority() default 1; }

C. @interface TestInfo { public String author; public int priority = 1; }

D. annotation TestInfo { String author(); int priority(); }

Solution

1. Step 1: Recall Java annotation syntax

   Annotations use the keyword @interface and define methods without bodies for elements.

2. Step 2: Check public @interface TestInfo { String author(); int priority() default 1; } syntax

   public @interface TestInfo { String author(); int priority() default 1; } correctly uses public @interface TestInfo and defines methods with optional default values.

3. Final Answer:

   public @interface TestInfo { String author(); int priority() default 1; } -> Option A

4. Quick Check:

   Annotation syntax = @interface + methods [OK]

Hint: Annotations use @interface keyword, not class or annotation [OK]

Common Mistakes:

• Using class instead of @interface
• Declaring fields instead of methods inside annotation
• Missing default keyword for optional elements

3. Given the custom annotation and usage below, what will be the output when printTestInfo() is called?

import java.lang.reflect.Method;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@interface TestInfo {
  String author();
  int priority() default 1;
}

public class SampleTest {
  @TestInfo(author = "Alice", priority = 3)
  public void testMethod() {}

  public static void printTestInfo() throws Exception {
    Method m = SampleTest.class.getMethod("testMethod");
    TestInfo info = m.getAnnotation(TestInfo.class);
    System.out.println(info.author() + ":" + info.priority());
  }
}

medium

A. Compilation error

B. Alice:1

C. Alice:3

D. null:0

Solution

1. Step 1: Understand annotation retrieval via reflection

   The method getAnnotation(TestInfo.class) fetches the annotation instance on testMethod.

2. Step 2: Check annotation values

   The annotation has author="Alice" and priority=3, so printing them outputs "Alice:3".

3. Final Answer:

   Alice:3 -> Option C

4. Quick Check:

   Reflection reads annotation values correctly [OK]

Hint: Annotation values print as set, defaults overridden [OK]

Common Mistakes:

• Assuming default priority is used instead of 3
• Expecting null because of missing retention policy
• Thinking reflection causes compile error

4. Consider this custom annotation definition:

@interface TestInfo {
  String author();
  int priority() default 1;
}

And this usage:

@TestInfo(author = "Bob")
public void test() {}

Why might the following code throw a NullPointerException when accessing priority()?

TestInfo info = testMethod.getAnnotation(TestInfo.class);
int p = info.priority();

medium

A. The priority method is missing in the annotation definition

B. The annotation is not retained at runtime, so info is null

C. The author value is missing, causing priority to be null

D. Annotations cannot have default values

Solution

1. Step 1: Check annotation retention policy

   If the annotation lacks @Retention(RetentionPolicy.RUNTIME), it is not available at runtime, so getAnnotation returns null.

2. Step 2: Understand NullPointerException cause

   Since info is null, calling info.priority() throws NullPointerException.

3. Final Answer:

   The annotation is not retained at runtime, so info is null -> Option B

4. Quick Check:

   Missing runtime retention = null annotation [OK]

Hint: Always add @Retention(RetentionPolicy.RUNTIME) for runtime use [OK]

Common Mistakes:

• Assuming default values cause null
• Thinking missing author causes error
• Believing annotations can't have defaults

5. You want to create a custom annotation @StepInfo to mark test steps with a description and an optional severity level (default "LOW"). You also want to process these annotations at runtime to print all step descriptions with their severity. Which combination of annotation elements and retention policy is correct to achieve this?

hard

A. @Retention(RetentionPolicy.RUNTIME) public @interface StepInfo { String description(); String severity() default "LOW"; }

B. @Retention(RetentionPolicy.CLASS) public @interface StepInfo { String description(); String severity() default "LOW"; }

C. @Retention(RetentionPolicy.SOURCE) public @interface StepInfo { String description(); String severity(); }

D. public @interface StepInfo { String description(); String severity() default "LOW"; }

Solution

1. Step 1: Choose correct retention for runtime processing

   To access annotations at runtime via reflection, use @Retention(RetentionPolicy.RUNTIME).

2. Step 2: Define annotation elements with default values

   Define description() as required and severity() with default "LOW" for optional use.

3. Final Answer:

   @Retention(RetentionPolicy.RUNTIME) public @interface StepInfo { String description(); String severity() default "LOW"; } -> Option A

4. Quick Check:

   Runtime retention + default value = correct annotation [OK]

Hint: Use RUNTIME retention to read annotations during tests [OK]

Common Mistakes:

• Using CLASS or SOURCE retention prevents runtime access
• Omitting retention causes default CLASS retention
• Not providing default for optional elements