Selenium developer interview questions

These interview questions and answers have been reviewed and verified by Bharath Krishnamurthy, Lead Software Test Automation Engineer at EPAM Anywhere. Thanks a lot, Bharath!

Are you preparing for a Selenium developer interview and wondering how to make your automation tester resume stand out? You've come to the right place. In this blog post, we've compiled a comprehensive list of both basic and advanced Selenium automation testing interview questions that you're likely to encounter.

We've also included a section dedicated to Selenium framework interview questions to help you showcase your understanding of how Selenium fits into a broader testing framework. Whether you're a novice or a seasoned professional, this blog post is designed to help you ace your next Selenium developer interview and make your Selenium automation tester resume shine. Let's dive in!

Selenium is a powerful open-source testing framework primarily used for web application testing. It lets developers write scripts in programming languages like Java, C#, Python, Ruby, and others. Selenium is highly flexible and efficient in identifying web elements and performing browser actions like clicking, filling in forms, or capturing screenshots.

It supports browsers like Chrome, Firefox, Safari, and Internet Explorer, enabling developers to test cross-browser. Selenium is not just a single tool but a software suite, each catering to the different testing needs of an organization. It comprises four main components: Selenium Integrated Development Environment (IDE), Selenium Remote Control (RC), WebDriver, and Selenium Grid. Selenium's capabilities to support multiple programming languages, browsers, and operating systems make it a desired choice for automation testing web applications.

Selenium is composed of several components, each with a specific role in aiding the development of web application tests. Here are the four main components:

1. Selenium integrated development environment (IDE): This is a simple, easy-to-use Firefox plugin that lets developers record, edit, and debug tests. It's perfect for beginners who are just getting started with Selenium.
2. Selenium remote control (RC): Also known as Selenium 1, this is a server that allows users to generate test scripts, which can then control a browser. Selenium RC has been deprecated and merged with WebDriver to form Selenium 2.
3. Selenium WebDriver: This is the successor to Selenium RC and the main component of Selenium 2. WebDriver provides an interface to execute test cases. These tests can then be run against most modern web browsers.
4. Selenium Grid: This tool is used for tests on machines against different browsers in parallel. Essentially, it allows for distributed test execution. It can execute tests on the new WebDriver as well as the old Remote Control.

Selenium 1, also known as Selenium Remote Control (RC), and Selenium 2, known as Selenium WebDriver, are both versions of Selenium, but they have some significant differences.

Selenium RC, the first version, acts as a server and uses JavaScript to automate the browser, which can lead to some restrictions due to the same-origin policy. Selenium RC also requires the test script to go through the RC server to interact with the browser, which can make the execution of tests slower.

On the other hand, Selenium WebDriver, or Selenium 2, the successor to Selenium RC, provides a more straightforward, programming interface for creating test scripts. Unlike Selenium RC, WebDriver doesn't rely on JavaScript for automation and interacts directly with the browser, which allows it to overcome the same-origin policy issue. It also doesn't require a server to interact with the browser, making the execution of tests faster.

In summary, while Selenium RC was a powerful tool for its time, Selenium WebDriver offers more efficient and direct browser control, making it the preferred choice for most testers today.

Assert and verify commands are both used in Selenium to validate the outcome of a test case, but they behave differently when the condition being checked fails.

The function assert verifies if a certain condition is true or false. If the condition is found to be true, further steps in the program will be executed. However, if the condition is false, the execution stops, and no further test steps are executed. In other words, if an assert command fails, the test is marked as failed, and test suite execution is aborted.

The verify command is capable of verifying the given condition's truth value without halting program execution, regardless of whether the condition is true or false. Even if the condition is false, the test will continue executing the remaining test steps. If a verify command fails, the test is marked as failed, but the test suite execution continues with the next test.

In summary, the main difference between assert and verify commands in Selenium is that assert will halt test execution on failure while verify will continue with further test step execution even when an assertion fails.

Locators in Selenium are a way to find elements on a web page. They are the HTML properties of web elements, which are used to identify elements uniquely on the webpage. There are eight locator types in Selenium:

1. ID: This is the most reliable and preferred way to locate an element, as IDs are supposed to be unique for each element.
2. Name: This locator is also reliable if the name attribute is defined for the element and the name is unique.
3. Class name: This locator finds the element by the class attribute. It's not the most reliable way as multiple elements can have the same class.
4. Tag name: This locator is used when the tag name of the element is unique.
5. Link text: This locator is used to find links by their exact text.
6. Partial link text: This locator finds a link by matching a part of the text.
7. CSS selector: This is a more advanced way to locate elements based on the CSS properties of the element.
8. XPath: This is the most flexible and complex way to locate elements. It's used when there is no other way to locate an element, and it can identify dynamic elements as well.

Selenium WebDriver is designed to automate web applications, and it doesn't directly support the handling of windows-based pop-ups. However, there are workarounds to handle these pop-ups.

One common method is to use third-party tools like AutoIT or Robot class in Java. AutoIT is a scripting language tool that can simulate keystrokes, mouse movements, and window manipulations to interact with windows-based pop-ups. You can write a script in AutoIT to handle a specific pop-up window and then call that script from your Selenium script.

The Robot class in Java can also be used to handle windows-based pop-ups. It can generate native system input events to interact with these pop-ups.

Using the capabilities of the WebDriver itself is an alternate approach. If the pop-up is a file download dialog, it is possible to set up the browser settings in such a way that files are automatically downloaded to a designated location without displaying the dialog.

Remember, these are workarounds and may not work in all scenarios. The best way to handle windows-based pop-ups would depend on the specific requirements of your test case.

The findElement() and findElements() methods in Selenium WebDriver are for locating elements on a web page. However, they have different functionalities and return types.

The findElement() method is used to find the first element on the web page that matches the specified locator value. If the method doesn't find any matching element, it throws a "NoSuchElementException". The return type of this method is a WebElement.

On the other hand, the findElements() method is used to find all the elements on the web page that match the specified locator value. If no matching elements are found, it doesn't throw an exception but returns an empty list. The return type of this method is a List of WebElements.

In summary, use findElement() when you know there's only one matching element, or you only need the first one. Use findElements() when you expect there to be multiple matching elements and you need to interact with all of them.

An exception test in Selenium is a type of test that is designed to pass when an exception is thrown by the system under test. This is typically used to verify that the system behaves correctly in error scenarios or when invalid input is provided.

In Selenium, you can write an exception test by using a try-catch block in your test method. In the try block, you perform the action that is expected to throw an exception. In the catch block, you verify that the exception thrown is the one you expected.

For example, if you're testing a login form, you might write an exception test that attempts to log in with an invalid username. The system should throw an exception in this case, and the test should pass if the correct exception is thrown.

It's important to note that exception tests should be used judiciously. While they're useful for testing error handling, they should not be used as a substitute for proper input validation and error checking in your test methods.

Handling frames in Selenium WebDriver involves switching the driver's focus from the main page to the frame and back. This is necessary because WebDriver can interact only with the elements in its current focus, which is the main page by default.

Selenium WebDriver provides the `switchTo().frame()` method to switch the focus to a frame. There are three ways to switch to a frame:

1. By index: If there are multiple frames on the page, they can be accessed by their index number, starting from 0 for the first frame.
2. By name or ID: If the frame has a 'name' or 'id' attribute, you can switch to the frame using these attributes.
3. By WebElement: If the frame is a WebElement, you can pass the WebElement to the `switchTo().frame()` method to switch to it.

After interacting with the elements inside the frame, you can get back to the main page using the `switchTo().defaultContent()` method. If there are nested frames, you can switch back to the parent frame using the `switchTo().parentFrame()` method.

`driver.close()` and `driver.quit()` are both methods in Selenium WebDriver used to close the browser, but they work in slightly different ways.

`driver.close()` is used to close the current browser window on which the focus is set. If you have multiple browser windows opened by WebDriver and the focus is currently on one window, `driver.close()` will close only that window.

On the other hand, `driver.quit()` is used to close all the browser windows that WebDriver has opened. Regardless of where the focus is, `driver.quit()` will close all the opened windows, and it also safely ends the session between the test script and the WebDriver.

In summary, use `driver.close()` when you want to close the current browser window, and use `driver.quit()` when you want to close all the windows and end the WebDriver session.

Alerts in Selenium can be handled using the Alert interface, which provides methods to interact with JavaScript alerts, confirms, and prompts.

To handle an alert, you first need to switch the driver's focus to the alert using the `switchTo().alert()` method. Once the focus is switched to the alert, you can interact with it using the Alert interface methods:

1. `accept()`: This method is used to click on the 'OK' button in the alert.
2. `dismiss()`: This method is used to click on the 'Cancel' button in the alert.
3. `getText()`: This method is used to capture the alert message.
4. `sendKeys(String stringToSend)`: This method is used to enter input in prompt alerts.

After interacting with the alert, you can switch the focus back to the main page using the `switchTo().defaultContent()` method. It's important to note that while the alert is present, you cannot interact with other elements on the page until the alert is accepted, dismissed, or the input is provided (for prompt alerts).

JavaScriptExecutor is an interface in Selenium WebDriver that is used to execute JavaScript code. It provides two methods: `executeScript()` and `executeAsyncScript()`, which allow you to run JavaScript commands directly within your Selenium WebDriver.

The `executeScript()` method is used to execute synchronous JavaScript code. It blocks the program execution until the script is executed, and then it returns the result of the script execution.

The `executeAsyncScript()` method is used to execute asynchronous JavaScript code. It doesn't block the program execution and returns a future object that you can use to get the result of the script execution when it's ready.

JavaScriptExecutor is particularly useful when you need to perform an operation that is not supported directly by WebDriver. For example, you can use it to scroll a web page, change the value of a hidden input field, or trigger a mouse hover event. It's a powerful tool that can extend the capabilities of WebDriver, but it should be used judiciously as it can make your tests more complex and harder to maintain.

In XPath, single slash (/) and double slash (//) are used to navigate through the elements in the XML document, but they have different uses.

A single slash (/) is used to create an absolute path in XPath. When the path starts with a single slash, it defines an absolute path to the required element. The search for the element begins from the root node or the document's start node. For example, `/html/body/div` would start searching from the root html node.

On the other hand, a double slash (//) is used to create a relative path in XPath. When the path starts with a double slash, it defines a search from anywhere within the document. It selects nodes in the document from the current node that matches the selection no matter where they are. For example, `//div` would search for all div elements present in the document.

In summary, a single slash (/) in XPath is used for absolute paths, while a double slash (//) is used for relative paths.

AutoIt is a freeware scripting language designed for automating the Windows GUI and general scripting. It uses a combination of simulated keystrokes, mouse movement, and window/control manipulation to automate tasks that are not possible or reliable with other languages.

In the context of Selenium WebDriver, AutoIt is often used as a workaround to handle windows-based pop-ups and dialogs, which WebDriver cannot interact with directly. For example, during file uploads, when a file dialog opens, Selenium WebDriver cannot interact with this dialog. AutoIt can be used to create a script that interacts with the file dialog, selecting a file, and then clicking the 'Open' button.

The AutoIt script can be called from the Selenium script, allowing seamless integration between the two. This makes AutoIt a valuable tool for handling scenarios in Selenium WebDriver that involve interactions with windows-based dialogs or pop-ups.

15. Discuss the difference between implicit wait and explicit wait in Selenium

Implicit wait and explicit wait in Selenium are both used to add waiting time in your test scripts, but they serve different purposes and behave differently.

Implicit wait is a type of wait that is set for the entire duration of your WebDriver. Once set, the WebDriver will wait for a specified amount of time for elements to appear in the DOM before throwing a "NoSuchElementException". The default setting is 0. The implicit wait is applicable for all the elements in your test script and it's set only once at the start of the WebDriver.

Explicit wait, on the other hand, is a type of wait that is set for a specific condition on a specific element. It instructs the WebDriver to wait until a certain condition occurs (like element is clickable, visible, etc.) before proceeding with the actions. If the condition is not met within the specified time, it throws a "TimeoutException". Explicit wait is more flexible as it allows you to set different waiting conditions for different elements.

16. What is WebDriverBackedSelenium?

WebDriverBackedSelenium is a class in Selenium WebDriver that allows you to use the Selenium RC interface while using WebDriver behind the scenes. This is particularly useful when migrating from Selenium RC to WebDriver, as it allows you to continue using your existing Selenium RC scripts while taking advantage of the features and benefits of WebDriver.

With WebDriverBackedSelenium, you can create an instance of Selenium that controls WebDriver, allowing you to use Selenium RC and WebDriver commands interchangeably. This means you can gradually migrate your test scripts to WebDriver, replacing Selenium RC commands with WebDriver equivalents one by one, rather than having to rewrite all your test scripts at once.

However, it's important to note that WebDriverBackedSelenium is part of the Selenium-WebDriver's backward compatibility layer, which is no longer actively developed. Therefore, it's recommended to migrate to WebDriver completely for new test development.

17. What is the difference between driver.getWindowHandles() and driver.getWindowHandle() in WebDriver?

driver.getWindowHandle() is used to handle the current window and it returns a handle of the current window in the form of a string.

driver.getWindowHandles() is used to handle multiple windows. It returns a set of handles of all the open windows.

18. How can you handle keyboard and mouse actions using Selenium?

Selenium WebDriver provides the Actions class to handle keyboard and mouse events. The Actions class has various methods to perform operations like click, double click, right click, drag and drop, mouse hover, and more.

For keyboard actions, you can use methods like `sendKeys()`, `keyDown()`, and `keyUp()`. For example, you can simulate pressing a key using `keyDown(Keys.SHIFT)` and then release it using `keyUp(Keys.SHIFT)`.

For mouse actions, you can use methods like `click()`, `doubleClick()`, `contextClick()`, `dragAndDrop()`, and `moveToElement()`. For example, you can simulate a mouse hover over an element using `moveToElement(element)`.

To perform these actions, you need to create an object of the Actions class and then call the required method on that object. After defining the action, you need to call the `perform()` method to execute the action.

It's important to note that not all browsers and operating systems support all keyboard and mouse events, and the exact behavior may vary depending on the browser and operating system.

19. What is the use of DesiredCapabilities in WebDriver?

DesiredCapabilities is a class in Selenium WebDriver that is used to set the properties of the WebDriver, like browser name, platform, and other capabilities. It's primarily used when you need to specify certain driver configurations or when you're running tests on a remote WebDriver.

For example, you can use DesiredCapabilities to set the type of browser (Chrome, Firefox, etc.), the version of the browser, and the platform (Windows, Linux, etc.) for your tests. You can also use it to configure browser-specific capabilities. For instance, you can set Chrome to start in incognito mode, or Firefox in private browsing mode.

In addition to this, DesiredCapabilities is used in Selenium Grid, where you need to run your tests on different machines with different browsers and platforms. You can specify the capabilities for each test to ensure they run on the correct machine.

However, it's important to note that DesiredCapabilities is being deprecated in Selenium, and it's recommended to use the specific Options classes for each browser, like ChromeOptions, FirefoxOptions, etc. These classes provide a type-safe, more readable way to configure the browser-specific capabilities.

20. How can you handle network latency in Selenium WebDriver?

You can manage network latency by using driver.manage().timeouts().pageLoadTimeout() method which waits for a page to load before throwing a "TimeoutException".

21. How can you retrieve CSS properties of an element?

In Selenium WebDriver, you can retrieve the CSS properties of a web element using the `getCssValue()` method. This method fetches the value of a given CSS property of the web element.

Here's how you can use it:

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

String cssValue = element.getCssValue("property-name");

In the above code, replace "myId" with the actual id of your element and "property-name" with the name of the CSS property you want to retrieve. The `getCssValue()` method will return the value of the specified CSS property as a string.

For example, if you want to get the color of an element, you can use `element.getCssValue("color")`. This will return the color of the element in RGB format.

Remember, the property name is case-sensitive, so make sure to use the exact name as specified in the CSS.

22. How can you handle dynamic web elements in Selenium?

Dynamic web elements can be handled in Selenium using XPath. XPath provides various functions, axes and operators that can be used to create complex expressions to handle dynamic elements.

23. How can you select a value in a dropdown?

In Selenium WebDriver, you can select a value in a dropdown using the Select class. The Select class provides methods of interacting with dropdown options.

Here's how you can use it:

WebElement dropdown = driver.findElement(By.id("myDropdown"));

Select select = new Select(dropdown);

In the above code, replace "myDropdown" with the actual id of your dropdown element. Once you have an instance of the Select class, you can select an option in three ways:

1. By visible text: `tselect.selectByVisibleText("Option1");` This will select the option with the visible text "Option1".
2. By value: `select.selectByValue("1");` This will select the option with the value "1".
3. By index: `select.selectByIndex(1);` This will select the option at index 1.

Remember, the Select class can only be used with `select` elements. If your dropdown is not a `select` element, you'll need to use other methods to interact with it.

24. How can you perform a drag-and-drop action in Selenium?

In Selenium WebDriver, you can perform drag and drop actions using the Actions class. The Actions class provides a method `dragAndDrop()` that you can use to simulate the drag and drop action.

Here's how you can use it:

WebElement sourceElement = driver.findElement(By.id("source"));

WebElement targetElement = driver.findElement(By.id("target"));

Actions actions = new Actions(driver);

actions.dragAndDrop(sourceElement, targetElement).perform();

In the above code, replace "source" with the actual id of your source element (the element you want to drag) and "target" with the actual id of your target element (the location where you want to drop the source element).

The `dragAndDrop()` method takes two parameters: the source element and the target element. It clicks and holds the source element, moves it to the location of the target element, and then releases the mouse.

Remember, not all browsers and operating systems support all keyboard and mouse events, and the exact behavior may vary based on the browser and operating system.

25. How can you handle AJAX calls in Selenium?

Dealing with AJAX requests while using Selenium can present difficulties since AJAX permits web pages to be updated asynchronously by exchanging data with a web server in the background. As a result, web elements may load at varying times, and Selenium could attempt to interact with an element before it is loaded, resulting in errors.

To handle AJAX calls, you can use the WebDriverWait and ExpectedConditions classes in Selenium. WebDriverWait allows you to set a maximum amount of time to wait for a condition, and ExpectedConditions provides a set of predefined conditions to wait for.

Here's an example of how you can use it:

WebDriverWait wait = new WebDriverWait(driver, 20);

WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("elementId")));

In the above code, Selenium will wait up to 20 seconds for the element with the id "elementId" to become visible. If the element becomes visible within 20 seconds, it will proceed with the next step. If not, it will throw a TimeoutException.

This approach allows you to wait for elements to load as a result of an AJAX call, making your tests more reliable. However, it's important to use explicit waits judiciously to avoid making your tests slow.

26. How can you take a screenshot in Selenium WebDriver?

Taking a screenshot in Selenium WebDriver can be done using the `TakesScreenshot` interface. This interface has a method `getScreenshotAs()` that can be used to capture a screenshot and store it in various ways.

Here's how you can use it:

TakesScreenshot screenshot = (TakesScreenshot) driver;

File src = screenshot.getScreenshotAs(OutputType.FILE);

FileUtils.copyFile(src, new File("path/to/screenshot.png"));

In the above code, you first cast the driver to `TakesScreenshot`. Then, you call the `getScreenshotAs()` method with `OutputType.FILE` as the argument, which returns a `File` object representing the screenshot. Finally, you use `FileUtils.copyFile()` to save the screenshot to your desired location.

Remember to replace "path/to/screenshot.png" with the actual path where you want to save the screenshot. Also, note that you need to handle the `IOException` that `FileUtils.copyFile()` can throw.

This will capture a screenshot of the entire page currently loaded in the driver. If you want to capture a screenshot of a specific element, you'll need to use other methods.

27. How can you handle dynamic web elements in Selenium?

You can handle dynamic elements in Selenium by using dynamic XPath or CSS Selectors. These locators can be created using contains(), starts-with(), ends-with() functions. You can also use regular expressions in CSS Selectors to handle dynamic elements.

28. How can you handle browser navigation in Selenium WebDriver?

You can handle browser navigation in Selenium WebDriver using the navigate() methods. You can navigate to an URL using to(String url), navigate back using back(), navigate forward using forward(), and refresh the current page using refresh().

29. How can you perform the mouse hover action in Selenium WebDriver?

You can perform mouse hover action using the Actions class in Selenium WebDriver. The Actions class provides a method `moveToElement()` that you can use to simulate the mouse hover action.

30. How can you handle multiple windows in Selenium WebDriver?

You can handle multiple windows in Selenium WebDriver using the `getWindowHandles()` and `switchTo().window()` methods. `getWindowHandles()` returns a set of window handles which can be used to iterate over all open windows. `switchTo().window()` method can be used to switch focus between windows.

31. How can you use JavaScript in Selenium WebDriver?

You can use JavaScript in Selenium WebDriver using the JavaScriptExecutor interface. This interface provides methods to execute JavaScript commands directly within your Selenium WebDriver.

32. How can you handle page scrolling in Selenium WebDriver?

You can handle page scrolling in Selenium WebDriver using the JavaScriptExecutor interface. You can use JavaScript commands like `window.scrollTo(x-coord, y-coord)` or `element.scrollIntoView()` to scroll to a specific location or element.

33. How can you handle file uploads in Selenium WebDriver?

You can handle file uploads in Selenium WebDriver by sending the absolute file path to the file input element using the `sendKeys()` method.

34. How can you handle authentication pop-ups in Selenium WebDriver?

You can handle authentication pop-ups in Selenium WebDriver by passing the username and password in the URL itself or by using the Alert interface to interact with the authentication pop-up.

35. How can you handle SSL certificates in Selenium WebDriver?

You can handle SSL certificates in Selenium WebDriver by using DesiredCapabilities class to set the browser-specific capabilities or by using the specific Options classes for each browser, like ChromeOptions, FirefoxOptions, etc.

36. How can you use Selenium WebDriver with a proxy?

You can use Selenium WebDriver with a proxy by setting the proxy details in the DesiredCapabilities or the specific Options classes for each browser.

37. How can you run Selenium WebDriver tests in the cloud?

You can run Selenium WebDriver tests in the cloud using cloud testing platforms like Sauce Labs, BrowserStack, etc. These platforms provide Selenium WebDriver APIs that you can use to run your tests on their infrastructure.

38. How can you run Selenium WebDriver tests in parallel?

You can run Selenium WebDriver tests in parallel using testing frameworks that support parallel execution, like TestNG, JUnit, etc. You can also use Selenium Grid to run your tests on multiple machines in parallel.

39. How can you integrate Selenium WebDriver with other tools like Jenkins, Maven, etc.?

You can integrate Selenium WebDriver with other automation tools like Jenkins, Maven, etc. by using their respective plugins or APIs. For example, you can use the Maven Surefire Plugin to run your Selenium tests as part of your Maven build. Similarly, you can use the Jenkins Selenium Plugin to run your Selenium tests as part of your Jenkins build.

40. How can you handle CAPTCHA in Selenium WebDriver?

CAPTCHA is designed to prevent automation, so there's no direct way to handle it using Selenium WebDriver. However, there are some workarounds like using third-party CAPTCHA solving services or asking your development team to disable CAPTCHA on the testing environment.

In conclusion, preparing for these Selenium developer interview questions can notably increase your chances of success when you apply for automation tester jobs at EPAM Anywhere. Understanding the core concepts, functionalities, and applications of Selenium WebDriver is crucial. Remember, practical knowledge and hands-on experience are as important as theoretical knowledge. So, keep practicing and enhancing your automation testing skills. Good luck with your interview!