@FindBy annotations in Selenium Java - Framework Patterns

Framework Mode - @FindBy annotations

Folder Structure

src/
└── test/
    └── java/
        └── com/
            └── example/
                ├── pages/
                │   └── LoginPage.java
                ├── tests/
                │   └── LoginTest.java
                ├── utils/
                │   └── WebDriverManager.java
                └── config/
                    └── TestConfig.java
  

Test Framework Layers

• Driver Layer: Manages WebDriver setup and teardown (e.g., WebDriverManager.java).
• Page Objects: Classes representing web pages using @FindBy annotations to locate elements (e.g., LoginPage.java).
• Tests: Test classes that use page objects to perform actions and assertions (e.g., LoginTest.java).
• Utilities: Helper classes for common functions like waits, screenshots, or logging.
• Configuration: Holds environment settings, browser types, and credentials (e.g., TestConfig.java).

Configuration Patterns

Use a TestConfig.java or config.properties file to manage:

• Environment URLs (dev, test, prod)
• Browser types (Chrome, Firefox, Edge)
• User credentials (stored securely or mocked)

Load these settings at runtime to keep tests flexible and avoid hardcoding.

Test Reporting and CI/CD Integration

• Use TestNG or JUnit reports for test execution results.
• Integrate with CI/CD tools like Jenkins or GitHub Actions to run tests automatically on code changes.
• Generate HTML reports with screenshots on failure for easy debugging.

Best Practices for @FindBy Annotations

• Use @FindBy to locate elements clearly and avoid using brittle locators like absolute XPaths.
• Keep locators private and expose only meaningful methods in page objects.
• Use explicit waits in page object methods to handle dynamic page content.
• Group related elements logically in page objects for readability and maintenance.
• Initialize page objects with PageFactory.initElements(driver, this) to enable @FindBy processing.

Self Check

Where would you add a new @FindBy annotated element for a "Remember Me" checkbox on the login page?

Key Result

Use @FindBy annotations in page objects to locate web elements cleanly and maintainably.

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