@FindBy annotations in Selenium Java - Build an Automation Script

Verify login functionality using @FindBy annotations

Preconditions (2)

Step 1: Open the browser and navigate to the login page URL

Step 2: Locate the email input field using @FindBy annotation and enter '[e-mail]'

Step 3: Locate the password input field using @FindBy annotation and enter 'Password123!'

Step 4: Locate the login button using @FindBy annotation and click it

Step 5: Wait for the dashboard page to load

Step 6: Verify that the current URL contains '/dashboard'

✅ Expected Result: User is successfully logged in and redirected to the dashboard page with URL containing '/dashboard'

Automation Requirements - Selenium WebDriver with TestNG

Assertions Needed:

Verify the URL contains '/dashboard' after login

Best Practices:

Use @FindBy annotations to locate web elements

Use Page Object Model to organize page elements and actions

Use explicit waits to wait for page load or element visibility

Use meaningful method names and clear assertions

Automated Solution

Selenium Java

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
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 LoginPage {
    private WebDriver driver;
    private WebDriverWait wait;

    @FindBy(id = "email")
    private WebElement emailInput;

    @FindBy(id = "password")
    private WebElement passwordInput;

    @FindBy(id = "loginBtn")
    private WebElement loginButton;

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

    public void enterEmail(String email) {
        wait.until(ExpectedConditions.visibilityOf(emailInput));
        emailInput.clear();
        emailInput.sendKeys(email);
    }

    public void enterPassword(String password) {
        wait.until(ExpectedConditions.visibilityOf(passwordInput));
        passwordInput.clear();
        passwordInput.sendKeys(password);
    }

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

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

    @BeforeClass
    public void setUp() {
        // Initialize WebDriver (e.g., ChromeDriver) here
        driver = new org.openqa.selenium.chrome.ChromeDriver();
        driver.manage().window().maximize();
        driver.get("https://example.com/login");
        loginPage = new LoginPage(driver);
    }

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

        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        wait.until(ExpectedConditions.urlContains("/dashboard"));

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

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

This code uses the @FindBy annotation to locate the email input, password input, and login button elements on the login page. The LoginPage class represents the login page using the Page Object Model pattern, which helps keep the code organized and reusable.

In the LoginTest class, the test opens the browser, navigates to the login page, and uses the LoginPage methods to enter credentials and click the login button. It then waits explicitly for the URL to contain '/dashboard' to confirm successful login. Finally, it asserts that the URL is correct.

Explicit waits ensure the test waits for elements to be ready before interacting, avoiding flaky tests. The test cleans up by closing the browser after running.

Common Mistakes - 4 Pitfalls

Using hardcoded locators inside test methods instead of @FindBy annotations

Not using explicit waits before interacting with elements

{'mistake': 'Using Thread.sleep() to wait for elements', 'why_bad': "Thread.sleep() is inefficient and slows tests unnecessarily; it also doesn't handle dynamic wait times.", 'correct_approach': 'Use explicit waits that wait only as long as needed.'}

{'mistake': 'Not initializing PageFactory in the Page Object constructor', 'why_bad': "Without PageFactory.initElements(), @FindBy elements won't be initialized and will cause NullPointerException.", 'correct_approach': 'Call PageFactory.initElements(driver, this) in the constructor.'}

Bonus Challenge

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

Show Hint

Practice

1. What is the main purpose of the @FindBy annotation in Selenium Java?

easy

A. To execute JavaScript code on the web page

B. To locate web elements on a page using different strategies

C. To start the Selenium WebDriver session

D. To take screenshots during test execution

Solution

1. Step 1: Understand the role of @FindBy

   The @FindBy annotation is used to specify how to find a web element on a page, such as by id, name, xpath, etc.

2. Step 2: Compare with other options

   Options B, C, and D describe other Selenium features but not element locating.

3. Final Answer:

   To locate web elements on a page using different strategies -> Option B

4. Quick Check:

   @FindBy locates elements = A [OK]

Hint: Remember: @FindBy is for locating elements only [OK]

Common Mistakes:

• Confusing @FindBy with WebDriver commands
• Thinking @FindBy executes scripts
• Assuming @FindBy starts browser sessions

2. Which of the following is the correct syntax to locate a web element by its ID using @FindBy annotation?

easy

A. @FindBy(id = "submitBtn")

B. @FindBy(name = submitBtn)

C. @FindBy(xpath = submitBtn)

D. @FindBy(css = #submitBtn)

Solution

1. Step 1: Check correct attribute usage

   The @FindBy annotation requires the attribute name and value as a string. For ID, it is id = "value".

2. Step 2: Validate each option

   @FindBy(id = "submitBtn") correctly uses id = "submitBtn". @FindBy(name = submitBtn) misses quotes. @FindBy(xpath = submitBtn) uses xpath but without quotes. @FindBy(css = #submitBtn) uses CSS selector but with incorrect syntax (should be css = "#submitBtn").

3. Final Answer:

   @FindBy(id = "submitBtn") -> Option A

4. Quick Check:

   Correct syntax uses id with quotes = B [OK]

Hint: Use quotes around locator values in @FindBy [OK]

Common Mistakes:

• Omitting quotes around locator values
• Mixing locator types incorrectly
• Using invalid syntax for CSS selectors

3. Given the following code snippet, what will be the output when button.isDisplayed() is called?

public class LoginPage {
  @FindBy(name = "loginBtn")
  WebElement button;

  public LoginPage(WebDriver driver) {
    PageFactory.initElements(driver, this);
  }
}

// In test method:
LoginPage page = new LoginPage(driver);
boolean visible = page.button.isDisplayed();
System.out.println(visible);

medium

A. Throws NullPointerException because button is not initialized

B. false always because @FindBy does not locate elements

C. true if the element with name 'loginBtn' is visible on the page

D. Compilation error due to missing @FindBy import

Solution

1. Step 1: Understand PageFactory initialization

   The constructor calls PageFactory.initElements(driver, this), which initializes all @FindBy annotated elements, including button.

2. Step 2: Check behavior of isDisplayed()

   If the element with name 'loginBtn' exists and is visible, isDisplayed() returns true; otherwise false. No NullPointerException occurs because initialization is done.

3. Final Answer:

   true if the element with name 'loginBtn' is visible on the page -> Option C

4. Quick Check:

   PageFactory initializes elements = true if visible [OK]

Hint: PageFactory.initElements must be called to avoid null elements [OK]

Common Mistakes:

• Assuming elements are null without initialization
• Confusing isDisplayed() with element presence
• Ignoring the need to call PageFactory.initElements

4. Identify the error in the following code snippet using @FindBy:

public class HomePage {
  @FindBy(xpath = "//button[@id='start']")
  WebElement startButton;

  public HomePage(WebDriver driver) {
    // Missing initialization
  }
}

medium

A. Missing call to PageFactory.initElements to initialize elements

B. Incorrect XPath syntax in @FindBy annotation

C. WebElement should be declared as private

D. startButton should be initialized manually with driver.findElement

Solution

1. Step 1: Check element initialization

   The constructor does not call PageFactory.initElements(driver, this), so startButton remains null.

2. Step 2: Validate other options

   XPath syntax is correct. WebElement visibility (private/public) is optional. Manual initialization is not needed if PageFactory is used.

3. Final Answer:

   Missing call to PageFactory.initElements to initialize elements -> Option A

4. Quick Check:

   PageFactory.initElements missing = D [OK]

Hint: Always call PageFactory.initElements in constructor [OK]

Common Mistakes:

• Forgetting to initialize elements with PageFactory
• Assuming XPath syntax errors without checking
• Thinking manual findElement is required with @FindBy

5. You want to locate multiple elements with the same class name using @FindBy. Which declaration is correct to store all matching elements in a list?

public class ProductsPage {
  // Which line is correct?
}

hard

A. @FindBy(css = ".product-item")
WebElement products;

B. @FindBy(className = "product-item")
WebElement products;

C. @FindBy(xpath = "//div[@class='product-item']")
WebElement products;

D. @FindBy(className = "product-item")
List<WebElement> products;

Solution

1. Step 1: Understand locating multiple elements

   To store multiple elements, the field must be a List<WebElement>. Using @FindBy with className locator is valid.

2. Step 2: Check each option's type and locator

   @FindBy(className = "product-item") List<WebElement> products; uses List<WebElement> with correct locator. Options A, B, and D use single WebElement, which can only hold one element.

3. Final Answer:

   @FindBy(className = "product-item") List<WebElement> products; -> Option D

4. Quick Check:

   Multiple elements need List<WebElement> = C [OK]

Hint: Use List<WebElement> for multiple elements with @FindBy [OK]

Common Mistakes:

• Declaring multiple elements as single WebElement
• Using wrong locator type for multiple elements
• Forgetting to import java.util.List