Selenium Interview Questions

First let’s have a quick overview of quality engineering

What is Quality in software? Why Quality engineers are important in Software?

Quality in software refers to the degree to which a software product meets the specified
requirements, user expectations, and is free from defects. It encompasses various attributes such
as functionality, reliability, usability, efficiency, maintainability, and portability. High-quality
software not only performs its intended functions correctly but also provides a positive user
experience, is secure, and can be easily maintained and updated.

Quality engineers play a crucial role in ensuring software quality throughout the development
lifecycle. They are responsible for implementing quality practices, focusing on test automation,
and developing automation test frameworks and tools. By integrating quality and testing into
every stage of the product development process, quality engineers help achieve rapid, reliable,
and secure software releases. Their proactive approach to quality engineering involves
continuous testing, automated testing, and optimized test environments, which are essential for
maintaining high-quality software in complex and dynamic environments.

Quality engineers also collaborate closely with developers and other engineers, providing
guidance on best practices and addressing quality risks. Their expertise in performance testing,
cloud technologies, and shift-left testing strategies ensures that software is resilient, scalable, and
secure. By embedding quality into every line of code and process, quality engineers help
organizations build robust, scalable, and secure systems that can withstand the demands of
today's digital landscape.

What is selenium?

Selenium is a widely used open-source tool for automating web browsers. It provides a suite of
tools to automate web applications for testing purposes, but it is not limited to just that. Here are
some key components and features of Selenium:

1. Selenium WebDriver: This is the core component of Selenium that allows you to interact
with web browsers. It provides a programming interface to create and execute test scripts
in various programming languages such as Java, C#, Python, and Ruby.
2. Selenium IDE: This is an integrated development environment for Selenium scripts. It is a
Firefox and Chrome plugin that allows you to record, edit, and debug tests.
3. Selenium Grid: This component allows you to run tests on multiple machines and
browsers in parallel. It is particularly useful for cross-browser testing and can significantly
reduce the time required for test execution.
4. Selenium RC (Remote Control): This is a server that allows you to create test scripts in
any programming language and run them in any browser. However, it has been
deprecated in Favor of WebDriver.

Selenium supports automation on all major browsers, including Firefox, Internet Explorer,
Google Chrome, Safari, and Opera. It is also compatible with various operating systems
like Windows, macOS, and Linux.
 Can you explain the difference between Selenium WebDriver and Selenium Grid?

Feature Selenium WebDriver Selenium Grid

Automates web application Distributes and runs tests across multiple machines
Purpose
testing on a single machine and browsers in parallel

Architectur Directly interacts with the Uses a hub-node architecture (hub manages tests, n
e web browser odes execute tests)

Parallel Exe Runs tests sequentially on Allows parallel execution of tests on multiple machi
cution a single machine nes

Enables cross-browser testing by running tests on di

Cross-Brow Limited to the browser on t
fferent browsers and operating systems simultaneo
ser Testing he single machine
usly

Test Execut Longer, as tests run sequen Shorter, as tests run in parallel across multiple mach
ion Time tially ines

Ideal for developing and de Ideal for large-scale test execution and cross-brows
Use Case
bugging test scripts er testing

How do you find an element using Selenium WebDriver?

You can find elements using various locators provided by Selenium WebDriver, such as id, name,
className, tagName, linkText, partialLinkText, cssSelector, and xpath. For example:

WebElement element = driver.findElement(By.id("elementId"));

This line of code locates an element by its id attribute

3. What are the different types of waits available in Selenium WebDriver?

There are three main types of waits in Selenium WebDriver:

• Implicit Wait: Waits for a certain amount of time before throwing a

NoSuchElementException. java
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
• Explicit Wait: Waits for a specific condition to be met before proceeding with the next
step. java WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement element =
 wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("eleme
ntId")));
• Fluent Wait: Allows you to define the maximum amount of time to wait for a condition,
as well as the frequency with which to check the condition. java Wait<WebDriver>
wait = new FluentWait<WebDriver>(driver) .withTimeout(30,
TimeUnit.SECONDS) .pollingEvery(5, TimeUnit.SECONDS)
.ignoring(NoSuchElementException.class); WebElement element =
wait.until(new Function<WebDriver, WebElement>() { public WebElement
apply(WebDriver driver) { return
driver.findElement(By.id("elementId")); } });

4. How do you handle dropdowns in Selenium WebDriver?

You can handle dropdowns using the Select class. Here’s an example:

import org.openqa.selenium.support.ui.Select;
WebElement dropdown = driver.findElement(By.id("dropdownId"));
Select select = new Select(dropdown);
select.selectByVisibleText("OptionText");

5. What is the difference between findElement() and findElements() in Selenium

WebDriver?

• findElement(): Returns the first matching element on the current page. If no element is
found, it throws a NoSuchElementException. java WebElement element =
driver.findElement(By.id("elementId"));
• findElements(): Returns a list of all matching elements on the current page. If no
elements are found, it returns an empty list. java List<WebElement> elements =
driver.findElements(By.className("className"));

How do you handle alerts in Selenium WebDriver?

You can handle alerts using the Alert interface. Here’s an example:

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

alert.accept(); // To accept the alert
alert.dismiss(); // To dismiss the alert
alert.sendKeys("Text"); // To send text to the alert
alert.getText(); // To get the text from the alert

What is the Page Object Model (POM) in Selenium?

The Page Object Model is a design pattern that creates an object repository for web elements. It
helps in reducing code duplication and improving test maintenance. Each web page is
represented by a class, and the elements on the page are defined as variables in the class. Here’s
an example:
public class LoginPage {
WebDriver driver;
By username = By.id("username");
By password = By.id("password");
By loginButton = By.id("loginButton");

public LoginPage(WebDriver driver) {

this.driver = driver;
}

public void login(String user, String pass) {

driver.findElement(username).sendKeys(user);
driver.findElement(password).sendKeys(pass);
driver.findElement(loginButton).click();
}
}

How do you handle dynamic web elements in Selenium?

Dynamic web elements are those that change their properties (such as ID, class, or XPath)
dynamically. To handle these elements, you can use various strategies such as:

• Using relative XPath: Instead of using absolute XPath, use relative XPath to locate
elements based on their relationship with other stable elements. java WebElement
element =
driver.findElement(By.xpath("//div[@class='parent']//child::button"))
;
• Using CSS Selectors: CSS selectors can be more flexible and robust for locating dynamic
elements. java WebElement element =
driver.findElement(By.cssSelector("div.parent > button"));
• Using JavaScript Executor: You can use JavaScript to interact with dynamic elements.
java JavascriptExecutor js = (JavascriptExecutor) driver; WebElement
element = (WebElement) js.executeScript("return
document.querySelector('div.parent > button');");

Explain the architecture of Selenium WebDriver.

Selenium WebDriver follows a client-server architecture. The key components are:

• Client Libraries: These are language-specific bindings (Java, C#, Python, etc.) that allow
you to write test scripts.
• JSON Wire Protocol: This protocol facilitates communication between the client libraries
and the browser drivers.
• Browser Drivers: These are specific to each browser (ChromeDriver, GeckoDriver, etc.)
and act as a bridge between the test scripts and the browser.
• Browsers: The actual web browsers (Chrome, Firefox, etc.) where the tests are executed.
How can you perform mouse hover actions in Selenium?

You can perform mouse hover actions using the Actions class in Selenium. Here’s an example:

Actions actions = new Actions(driver);

WebElement element = driver.findElement(By.id("elementId"));
actions.moveToElement(element).perform();

This code moves the mouse to the specified element and performs the hover action.

How do you handle file uploads in Selenium?

You can handle file uploads by sending the file path to the file input element. Here’s an example:

WebElement uploadElement = driver.findElement(By.id("uploadId"));

uploadElement.sendKeys("C:\\path\\to\\file.txt");

This code locates the file input element and sends the file path to it, simulating a file upload.

How do you handle multiple windows in Selenium?

You can handle multiple windows using the getWindowHandles() and switchTo().window()
methods. Here’s an example:

String mainWindow = driver.getWindowHandle();

Set<String> allWindows = driver.getWindowHandles();
for (String window : allWindows) {
if (!window.equals(mainWindow)) {
driver.switchTo().window(window);
// Perform actions on the new window
driver.close();
}
}
driver.switchTo().window(mainWindow);

This code switches to each window, performs actions, and then switches back to the main
window.

How do you handle AJAX calls in Selenium?

To handle AJAX calls, you can use explicit waits to wait for the expected condition. Here’s an
example:

WebDriverWait wait = new WebDriverWait(driver, 10);

wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("ajaxElement
Id")));
This code waits until the AJAX element is visible before proceeding with the next steps.

How do you capture screenshots in Selenium?

You can capture screenshots using the TakesScreenshot interface. Here’s an example:

File screenshot = ((TakesScreenshot)

driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(screenshot, new File("path/to/screenshot.png"));

This code captures a screenshot and saves it to the specified path.

What are some best practices for writing Selenium test scripts?

1. Use Explicit Waits: Instead of using implicit waits, which can lead to longer test
execution times, use explicit waits to improve script performance. Explicit waits allow you
to wait for specific conditions to be met before proceeding with the next step
2. Avoid Blocking Sleep Calls: Using Thread.sleep() can make your tests slower and
less reliable. Instead, use waits that are more dynamic and responsive to the actual
conditions of the web elements
3. Name Test Cases and Test Suites Appropriately: Use meaningful names for your test
cases and test suites to make it easier to understand what each test is doing and to
facilitate better reporting.
4. Set Browser Zoom Level to 100%: Ensure that the browser zoom level is set to 100% to
avoid any discrepancies in element positioning and interaction
5. Maximize the Browser Window: Maximize the browser window at the start of your tests
to ensure that all elements are visible and interactable
6. Choose the Best-Suited Web Locator: Use the most appropriate locator strategy (e.g.,
id, name, cssSelector, xpath) to ensure that your tests are robust and less prone to
breakage
7. Create a Browser Compatibility Matrix for Cross-Browser Testing: Define a matrix of
browsers and versions to test against, ensuring that your application works across
different environments
8. Implement Logging and Reporting: Use logging and reporting tools to capture test
execution details and results. This helps in debugging and understanding test failures
9. Use Design Patterns and Principles: Implement design patterns like the Page Object
Model (POM) to create more maintainable and reusable code
10. Use BDD Framework with Selenium: Behavior-Driven Development (BDD) frameworks
like Cucumber can help in writing more readable and understandable test scripts
11. Follow a Uniform Directory Structure: Maintain a consistent directory structure for your
test scripts, resources, and configuration files to improve organization and maintainability
12. Use Data-Driven Testing for Parameterization: Implement data-driven testing to run
the same test with different sets of data, improving test coverage and efficiency
13. Do Not Use a Single Driver Implementation: Avoid hardcoding the WebDriver
implementation. Instead, use a factory pattern to create instances of different drivers
based on the test requirements
14. Come Up with Autonomous Test Case Design: Design test cases that are independent
and can be executed in any order without dependencies on other tests
15. Use Assert and Verify in Appropriate Scenarios: Use assertions to validate critical
conditions and verifications for non-critical checks to ensure that your tests provide
meaningful feedback
16. Avoid Code Duplication: Wrap common Selenium calls in utility methods to avoid code
duplication and improve maintainability
17. Leverage Parallel Testing in Selenium: Use parallel testing to run multiple tests
simultaneously, reducing the overall test execution time