Top Selenium Interview Questions and Answers

Selenium is a tool that helps test websites by automating browser actions, like clicking and typing. It has four components.

• IDE: Records tests.
• WebDriver: Runs tests using code.
• Grid: Runs tests on many browsers at once.
• Remote Control(RC): An old version, mostly replaced now.

Selenium is better than manual testing because it’s quicker and less effort once set up. It is good because it saves time, is easy to repeat tests, works on different browsers, and can test big websites easily.

Selenium locators help find elements on a webpage. id, name, className, tagName, linkText, partialLinkText, xpath,  and cssSelector are the main locators. Here are some examples with each.

driver.get() opens a webpage and waits for it to fully load.

Example: 

driver.navigate().to() also opens a page but lets you do some actions like back, forward, or refresh.

Example: 

Both work to open pages, but navigate() gives more control. 

driver.close() closes the current browser tab or window.

Example: 

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

Example: 

Absolute XPath starts from the root and shows the full path.

Example: 

Relative XPath starts from anywhere in the page and is shorter.

Example:

findElement() finds the first matching element. If none are found, it gives an error.

Example: 

findElements() finds all matching elements and returns a list. If none are found, returns an empty list.

Example:

A WebElement is any element on a webpage, like a button, link, or text box. You can interact with it by clicking, typing, or reading its text.

Example:

Selenium is mainly used to test web applications. It works with browsers, so it can't test mobile or desktop apps directly.

Example:

You can test a login page on Chrome using:

For mobile apps, tools like Appium are used instead.

Selenium supports many languages, but the most commonly used ones are Java, Python, and C#.

Example (Java):

Selenium also works with all major browsers like Chrome, Firefox, Edge, and Safari.

In Selenium, waits help pause the test until something happens on the page. There are three main types:

a. Implicit Wait

Waits for a set time for elements to appear.

Example:

Wait up to 10 seconds for elements to show up before throwing an error.

b. Explicit Wait

Waits for a specific condition before continuing.

Example:

c. Fluent Wait

Waits with polling and can ignore some exceptions.

Example:

To handle dropdowns in Selenium, we use the Select class. It works for <select> HTML tags.

Example:

Here’s a simple answer with an example and explanation inside the code:

This is how you handle alerts, pop-ups, and confirmation boxes in Selenium.

Page Object Model (POM) is a way to organize your test code by keeping page elements and actions in one place. It makes tests easier to read and maintain.

Example:
Create a class for the login page:

This keeps the code clean and easy to update when the page changes.

TestNG is a testing framework for running Selenium tests. It helps organize tests, run them in order, and create reports.

Example:

You write tests with @Test, then TestNG runs and manages them easily.

JavaScriptExecutor lets you run JavaScript code inside the browser from Selenium. It’s useful when Selenium can’t do something directly.

Example:

It helps do scrolling, clicking, or getting info with JavaScript.

The Actions class helps do mouse and keyboard actions like hover, click, or type.

Example:

It lets you simulate real user actions in tests.

In Selenium, to switch between multiple windows or tabs, you use window handles.

Example:

This helps control and switch between browser tabs or windows.

Common Selenium exceptions are:

• NoSuchElementException — when an element isn’t found
• TimeoutException — when waiting takes too long
• StaleElementReferenceException — when the page changes, and the  element is no longer valid

To handle these exceptions, use try-catch to catch and manage them.

Example:

To capture a screenshot in Selenium, use the TakesScreenshot interface.

Example:

This saves a screenshot of the current browser window.

Selenium Grid lets you run tests on different machines and browsers at the same time (parallel testing).

Example:

• Set up a Hub (central server)
• Connect Nodes (machines with browsers) to the Hub
• Run tests by telling Selenium to use the Hub URL

This way, tests run faster by running in parallel on many browsers or machines.

A data-driven framework means running the same test with different data inputs (like usernames or passwords).
To do it:

• Store test data in a file (like Excel or CSV)
• Read the data in your test
• Loop through the data and run the test for each set

Example: (reading data from Excel using Apache POI)

This lets you test many cases without writing the test again and again.

To run Selenium tests automatically using Jenkins (for CI/CD):

1. Install Jenkins and create a new job.
2. Connect your test code repository (like Git).
3. Add build steps to run your Selenium tests (using Maven, Gradle, or command line).
4. Run the job to trigger tests automatically on code changes.

Example: In Jenkins, use this command to run tests:

This helps catch bugs early by testing code every time it’s updated.

DesiredCapabilities tell Selenium what browser and settings to use when running tests.

Example:

This sets up a test to run on Chrome browser on Windows through Selenium Grid.

Cross-browser testing means running your tests on different browsers like Chrome, Firefox, and Edge.

To do it, set the browser you want before starting the test.

Example:

This lets you check if your website works on all browsers.

CAPTCHA and third-party logins are hard to automate because they need human input.
To handle,

• Use test accounts that don’t have CAPTCHA
• Ask developers to disable CAPTCHA in test environments
• Or skip those steps in automated tests

Example:
Instead of automating CAPTCHA, focus on testing the page after login:

This keeps tests simple and avoids CAPTCHA issues.

Selenium 4 has new features and improvements over Selenium 3.
Main differences are:

• Selenium 4 supports the new W3C WebDriver standard for better browser compatibility.
• It has a new Grid for easier setup and better scaling.
• Adds support for relative locators to find elements more easily.
• Improved browser devtools integration.

Example: Selenium 4 lets you find elements like this:

This makes tests easier and more reliable.

For dynamic elements that change often, use flexible locators like XPath with contains() or CSS selectors that rely on stable parts.

Example:

This way, your test won’t break if the full ID changes, but part stays the same.

Shadow DOM elements are hidden inside web components, so normal Selenium can’t access them directly.

To handle, use JavaScript to get inside the shadow root.

Example:

This lets you interact with elements inside Shadow DOM.

To test responsive design, change the browser window size in Selenium and check how the page looks.

Example:

This helps make sure your site works well on different screen sizes.