Selenium Interview Questions & Answers

Selenium is an open-source automation testing tool used to automate web browsers. It allows testers and developers to simulate user interactions like clicking buttons, filling forms, navigating pages, and validating results.

Selenium supports multiple programming languages such as Java, Python, C#, and JavaScript. It works with major browsers like Chrome, Firefox, Edge, and Safari.

Selenium consists of four major components:

• Selenium IDE - Record and playback tool.
• Selenium WebDriver - Core automation API.
• Selenium Grid - Run tests in parallel on multiple machines.
• Selenium RC - Older version, now deprecated.

In real projects, WebDriver and Grid are most commonly used.

WebDriver is the main component of Selenium used to automate browser actions. It directly communicates with the browser using browser-specific drivers like ChromeDriver or GeckoDriver.

Unlike Selenium RC, WebDriver does not use JavaScript injection. It communicates using browser-native automation support.

A locator is a way to identify web elements on a page. Selenium provides multiple locator strategies:

• id
• name
• className
• tagName
• linkText
• partialLinkText
• CSS Selector
• XPath

Choosing the right locator improves stability of automation scripts.

CSS Selector is generally faster and simpler for basic element selection.

XPath is more powerful and allows navigating up and down the DOM tree.

In interviews, mention that CSS cannot move backward in DOM while XPath can.

To launch Chrome browser in Java:

WebDriver driver = new ChromeDriver();
driver.get("https://example.com");

Before launching, the appropriate browser driver must be configured.

close() closes only the current browser window.

quit() closes all browser windows and ends the WebDriver session.

quit() is recommended in test frameworks.

Implicit wait tells Selenium to wait for a specified time before throwing NoSuchElementException.

It applies globally to all elements.

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

Explicit wait waits for a specific condition before proceeding.

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("login")));

Explicit wait is more reliable than implicit wait.

POM is a design pattern in Selenium where each webpage is represented as a class.

This improves maintainability, readability, and reusability of test scripts.

Dropdowns can be handled using the Select class:

Select select = new Select(driver.findElement(By.id("country")));
select.selectByVisibleText("India");

Methods available: selectByValue(), selectByIndex(), selectByVisibleText()

Selenium handles alerts using switchTo().alert():

Alert alert = driver.switchTo().alert();
alert.accept();

Methods include accept(), dismiss(), getText(), sendKeys().

To switch to frame:

driver.switchTo().frame("frameName");

To come back:

driver.switchTo().defaultContent();

Use getWindowHandles() to get all window IDs.

Switch using driver.switchTo().window(windowID).

Screenshots can be taken using TakesScreenshot interface:

File src = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);

Selenium Grid allows running test cases in parallel across multiple machines and browsers.

It improves execution speed and supports cross-browser testing.

Dynamic elements have changing IDs or attributes.

Best practices:

• Use contains() in XPath
• Use starts-with()
• Use relative locators

Example:

//input[contains(@id,"user")]

Data-driven testing separates test data from test logic.

Common methods:

• Using Excel with Apache POI
• Using CSV files
• Using TestNG DataProvider

StaleElementReferenceException occurs when element is refreshed.

Solution:

• Re-locate the element
• Use explicit wait
• Use retry logic

Headless testing runs browser without GUI.

Useful for CI/CD pipelines.

ChromeOptions options = new ChromeOptions();
options.addArguments("--headless");

Steps:

1. Push code to repository
2. Configure Jenkins job
3. Add build step (Maven/Gradle)
4. Run tests automatically

This enables continuous testing.

findElement() returns a single WebElement. If the element is not found, it throws NoSuchElementException.

findElements() returns a list of WebElements. If no elements are found, it returns an empty list instead of throwing an exception.

Selenium 4 introduced relative locators to locate elements based on their position relative to other elements.

Example:

driver.findElement(with(By.tagName("input")).above(By.id("password")));

They improve readability but should be used carefully for stable layouts.

File upload can be handled by sending file path to input type="file".

driver.findElement(By.id("upload")).sendKeys("C:\file.txt");

No need to handle OS dialog if input element is accessible.

Fluent Wait is a type of explicit wait that defines maximum wait time, polling frequency, and ignores specific exceptions.

Wait wait = new FluentWait<>(driver)
.withTimeout(Duration.ofSeconds(20))
.pollingEvery(Duration.ofSeconds(2))
.ignoring(NoSuchElementException.class);

Scrolling can be handled using JavaScriptExecutor.

JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollBy(0,500)");

This is useful for lazy-loaded elements.

Shadow DOM is used in modern web apps where elements are encapsulated inside shadow roots.

To access them, use JavaScriptExecutor:

JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement shadowRoot = (WebElement) js.executeScript("return arguments[0].shadowRoot", element);

Dynamic tables can be handled using XPath loops or iterating through rows and columns.

Example approach:

• Locate table
• Get all rows using findElements()
• Loop through rows and validate cell values

Assert stops execution if condition fails.

Verify logs failure but continues execution.

In TestNG, assertions are commonly used for validation.

Browser execution can be parameterized using TestNG XML or command-line arguments.

This helps run tests across multiple browsers dynamically.

WebDriver is used for local browser automation.

RemoteWebDriver is used when running tests on Selenium Grid or remote machines.

A scalable framework includes:

• Page Object Model
• Reusable utilities
• Data-driven approach
• Proper logging
• CI/CD integration

Framework design is often asked in senior-level interviews.

CAPTCHA cannot be automated directly because it is designed to block bots.

Solutions:

• Disable CAPTCHA in test environment
• Use test bypass mechanism

Common exceptions include:

• NoSuchElementException
• StaleElementReferenceException
• TimeoutException
• ElementNotInteractableException

Auto-suggestions can be handled by:

• Typing partial text
• Waiting for suggestion list
• Selecting desired suggestion using loop

Cross-browser testing ensures application works across different browsers.

It can be implemented using:

• Selenium Grid
• Cloud platforms like BrowserStack
• Parameterized WebDriver setup