Selenium Interview Questions and Answers

Selenium is a suite of tools for automated web testing.  It is composed of

• Selenium IDE (Integrated Development Environment) :  It is a tool to record the test cases and Selenium IDE is having playback option, it has a plug-in for firefox.
• WebDriver and RC:  It provide the APIs for a variety of languages like Java, .NET, PHP, etc. With most of the browsers WebDriver and RC works.
• Grid: It helps to distribute the test cases to various machine at the same time , which reduces the testing time.

• Automation testing is a process of automating the manual process to test the application/system under test.

• Automation testing get helps from the separate automation tool, which helps you to test the test cases repeatedly in future testing.

Benefits of Automation testing are:

1. Supports execution of repeated test cases.
2. Aids in testing a large test matrix.
3. Enables parallel execution.
4. Encourages unattended execution.
5. Improves accuracy thereby reducing human-generated errors.
6. Saves time and money.

• Selenium RC – Remote Control came out in early 2004.

• It exposed a set of client APIs which use to send commands to a server to perform actions on the browser.Selenium RC a.k.a. Remote Control came out in early 2004.
• It is a collection of java scripts and does not have UI.
• It exposed a set of client APIs which use to send commands to a server to perform actions on the bIt exposed a set of client APIs which use to send commands to a server to perform actions on the browser.

• Selenium 2.0 WebDriver is a set of native APIs which directly send commands to the browser instead of delegating to a server.

• It’s release came out in 2011. It provided the native WebDriver API interface replacing the old client-server API model.

• It was a major WebDriver upgrade which landed up in 2016.

• It is superior to 2.0 because it implemented the W3C specifications for Webdriver APIs to make them a global standard.

• Until 3.0, it was the Selenium community that was supplying Web drivers for specific browsers. But now, they provide their respective drivers that support the standard Web driver API interface.

• Selenium v1 included only three suite of tools: Selenium IDE, Selenium RC and Selenium Grid. Note that there was no WebDriver in Selenium v1.

• Selenium WebDriver was introduced in Selenium v2. With the onset of WebDriver, Selenium RC got depreciated and is not in use.

• Older versions of RC is available in the market though, but support for RC is not available. Currently, Selenium v3 is in use, and it comprises of IDE, WebDriver and Grid.

• IDE is used for recording and playback of tests, WebDriver is used for testing dynamic web applications via a programming interface and Grid is used for deploying tests in remote host machines.

Exceptions in Selenium are similar to exceptions in other programming languages. The most common exceptions in Selenium are:

• Timeout Exception: This exception is throw the test case when a command performing an operation does not complete in the stipulated time.
• NoSuchElement Exception: When the element with given attributes is not found on the web page.
• ElementNotVisible Exception: This exception is throw the test case when the element is present in DOM (Document Object Model), but not visible on the web page.
• StaleElementException: This exception is thrown when the element is either deleted or no longer attached to the DOM.

An exception test is an exception that you expect will be thrown inside a test class. If you have written a test case in such way that it should throw an exception, then you can use the @Test annotation and specify which exception you will be expecting by mentioning it in the parameters.

For Example:

 @Test(expectedException = NoSuchElementException.class)

Do note the syntax, where the exception is suffixed with .class

Following are the barriers in Selenium.

We can’t test desktop application the usage of Selenium.
We can’t take a look at web services using Selenium.
For developing robust scripts in Selenium WebDriver, programming language knowledge is required.
We have to remember on external libraries and tools for performing tasks like – logging(log4J), testing framework-(testNG, JUnit), analyzing from external files(POI for excels) etc.

Page Object Model is a design pattern for creating an Object Repository for web UI elements. Each web page in the application is required to have it’s own corresponding page class. The page class is thus responsible for finding the WebElements in that page and then perform operations on those WebElements.

The advantages of using POM are:

• Allows us to separate operations and flows in the UI from Verification – improves code readability.
• Since the Object Repository is independent of Test Cases, multiple tests can use the same Object Repository.
• Reusability of code.

Page Object Model is a design pattern for creating an Object Repository for web UI elements. Each web page in the application is required to have it’s own corresponding page class. The web page class is accordingly accountable for finding the Web Elements in that page and then perform operations on those Web Elements.

The advantages of the usage of POM are:

• Allows us to separate operations and flows in the UI from Verification – improves code readability.
• Since the Object Repository is independent of Test Cases, multiple tests can use the identical Object Repository.
• Reusability of code.

• Allows us to separate operations and flows in the UI from Verification – improves code readability.
• Since the Object Repository is independent of Test Cases, multiple tests can use the same Object Repository.
• Reusability of code.

• It is none other than the HTMLUnitDriver, which is faster than all of its counterparts.

• The technical reason is that the HTMLUnitDriver doesn’t execute in the browser. It employs a simple HTTP request-response mechanism for test case execution.

• This method is far quicker than starting a browser to carry out test execution.

Selenium supports the following types of testing:

1. Functional Testing
2. Regression Testing

Selenium Grid is a tool which can distribute tests across multiple browsers or distinctive machines. It enables parallel execution of the test cases. Using this, we can configure to run hundreds of test cases at the same time as on separate devices or browsers.

• Selenium Grid allows the test cases to run on multiple platforms and browsers simultaneously, and hence, supports distributed testing.

• This ability to parallelize the testing is what makes us use the Selenium Grid.

There are number of benefits in the usage of the Selenium Grid.

• Support concurrent test execution and as a result saves us a lot of our time.
• It presents us with the ability to execute test cases in different browsers.
• After creating multi-machine nodes, we can use it to distribute exams and execute
  them.

A hub is analogous to a server that drives the parallel test execution on different machines.

• Page Factory gives an optimized way to implement Page Object Model. When we say it is optimized, it refers to the truth that the memory utilization is very properly and also the implementation is completed in an object oriented manner.

• Page Factory is used to initialize the elements of the Page Object or instantiate the Page Objects itself. Annotations for elements can also be created (and recommended) as the describing houses may not constantly be descriptive enough to differentiate one object from the other.

• The concept of keeping apart the Page Object Repository and Test Methods is observed here also. Instead of having to use ‘FindElements’, we use annotations like: @FindBy to find WebElement, and initElements method to initialize net elements from the Page Factory class.

• @FindBy can accept tag Name, partial LinkText, name, linkText, id, css, className & xpath as attributes.

XPath is used to locate the elements. Using XPath, we could navigate through elements and attributes in an XML document to locate web elements such as textbox, button, checkbox, Image etc in a web page.

• Single Slash “/” – Single slash is used to create XPath with absolute path. i.e. the XPath would be created to start selection from the document node/start node.

• Double Slash “//” – Double slash is used to create XPath with relative path i.e. the XPath would be created to start selection from anywhere within the document.

No. Selenium webDriver uses browser’s native method to automate the web applications. Since web services are headless, so we cannot automate web services using selenium webDriver.

Selenium Webdriver can be used for performing automated functional and regression testing.

The different locators in Selenium are-

1. Id
2. XPath
3. cssSelector
4. className
5. tagName
6. name
7. linkText
8. partialLinkText

By .className, we can select all the element belonging to a particular class. e.g. ‘.red‘ will select all elements having class ‘red‘.

By #idValue, we can select all the elements belonging to a particular class. e.g. ‘#userId‘ will select the element having id – userId.

Soft Assert: Soft Assert collects errors during @Test Soft Assert does no longer throw an exception when an assert fails and would proceed with the next step after the assert statement.

Hard Assert: Hard Assert throws an AssertException immediately when an assert statement fails and test suite continues with next @Test

• JavaScriptExecutor is an interface which provides a mechanism to execute Javascript through the Selenium WebDriver.

• It provides “executescript” and “executeAsyncScript” methods, to run JavaScript in the context of the currently selected frame or window.

Both sleep() and setSpeed() are used to delay the execution speed.

• setSpeed(): It set up the speed that will apply a delay time before every Selenium operation.

• sleep(): It sets up wait only for once when called in our Selenium script.

Both driver.get(“URL”) and driver.navigate().to(“URL”) commands are used to navigate to a URL passed as parameter.
There is a minor difference between the two commands-

1. driver.navigate() lets in moving lower back and forward in browser records the usage of driver.navigate().forward() and driver.navigate().back() commands.
2. In case of single page applications (where the URL is appended through ‘#’ to navigate to exceptional section of the page), driver.navigate().to() navigates to a particular part with the aid of changing the URL except clean the web page whereas driver.get() refreshes the web page also.
3. This fresh of page is also the primary reason because of which records is now not maintained in case of driver.get() command.

FirefoxDriver is a Java class, and it implements in WebDriver interface.

SearchContext acts as the super interface of Web Driver.

Before looking how to handle Stale Element Reference Exception through Page Object Model. Let’s see what is Stale Element Reference Exception first.

Stale means old, decayed, no longer fresh. Stale Element means an old element or no longer available element. Assume there is an element that is found on a web page referenced as a WebElement in WebDriver. If the DOM changes then the WebElement goes stale. If we try to interact with an element which is staled then the StaleElementReferenceException is thrown.

Using sendKeys() method we can type text in a textbox-

• WebElement searchTextBox = driver.findElement(By.id(“search”));

• searchTextBox.sendKeys(“searchTerm”);

• An absolute XPath is a way of locating an element using an XML expression beginning from root node. i.e. html node in case of web pages.

• The main disadvantage of absolute xpath is that even with slightest change in the UI or any element the whole absolute XPath fails. Absolute Xpath is separated by “/”

Example – html/body/div/div[2]/div/div/div/div[1]/div/input

A relative XPath is a way of locating an element the usage of an XML expression starting from somewhere in the HTML document. There are one-of-a-kind methods of growing relative XPaths which are used for growing sturdy XPaths (unaffected by way of adjustments in other UI elements).

Example – //input[@id=’username’]

WebDriverWait is applied on a certain element with defined expected condition and time. This wait is only applied to the specified element. This wait can also throw an exception when an element is not found.

FluentWait can define the maximum amount of time to wait for a specific condition and frequency with which to check the condition before throwing an “ElementNotVisibleException” exception.

• As per the official Selenium documentation, it is suggested no longer to combine both Implicit waits and Explicit Waits. Mixing both of them can cause unpredictable wait times.

• Implicit wait is described solely once in the code. It will remain equal throughout the driver object instance.

• Explicit wait is defined whenever it is necessary in the code. This wait will call at the time of execution. It is a conditional wait.

• Explicit wait will overwrite the implicit wait where ever explicit wait is applied. So, Explicit Wait receives first preference then Implicit Wait.

Following is the list of supported locators by Selenium.

• ID: Unique for every web element.
• Name: Same as ID although it is not unique.
• CSS Selector: Works on element tags and attributes.
• XPath: Searches elements in the DOM, reliable but slow.
• Class Name: Uses the class name attribute.
• Tag Name: Uses HTML tags to locate web elements.
• LinkText: Uses anchor text to locate web elements.
• Partial Link Text: Uses partial link text to find web elements.

Selenium provides the following methods for moving back and forth in a browser.

• navigate().forward() – to move to the next web page as per the browser’s history.
• navigate().back() – to move back to the previous page as per the browser’s history.
• navigate().refresh() – to reload the current page.
• navigate().to(“URL”) – to start a new browser window and opening up the specified link.

WebDriver exposes the following APIs to handle such popups.

• Dismiss(): It handles the alert by simulating the Cancel button.
• Accept(): It handles the alert window by simulating the Okay button.
• GetText(): You may call it to find out the text shown by the alert.
• SendKeys(): This method simulates keystrokes in the alert window.

This is a trick question which the interviewer will present to you. He can provide a situation where in there are 20 links in a web page, and we have to verify which of those 20 links are working and how many are not working (broken).

Since you need to verify the working of every link, the workaround is that, you need to send http requests to all of the links on the web page and analyze the response. Whenever you use driver.get() method to navigate to a URL, it will respond with a status of 200 – OK. 200 – OK denotes that the link is working and it has been obtained. If any other status is obtained, then it is an indication that the link is broken.

But how will you do that?

First, we have to use the anchor tags <a> to determine the different hyperlinks on the web page. For each <a> tag, we can use the attribute ‘href’ value to obtain the hyperlinks and then analyze the response received for each hyperlink when used in driver.get() method.

Alternative method to driver.get(“url”) method is driver.navigate.to(“url”).

• driver.get(): To open an URL and it will wait till the whole page gets loaded
• driver.navigate.to(): To navigate to an URL and It will not wait till the whole webpage gets loaded

We use Navigate interface to do navigate back and forth in a browser. It has methods to move back, forward as well as to refresh a page.

• driver.navigate().forward(); – to navigate to the next web page with reference to the browser’s history.
• driver.navigate().back(); – takes back to the previous webpage with reference to the browser’s history.
• driver.navigate().refresh(); – to refresh the current web page thereby reloading all the web elements.
• driver.navigate().to(“url”); – to launch a new web browser window and navigate to the specified URL.

• A keyword driven framework is one in which the actions are associated with keywords and kept in external files e.g. an action of launching a browser will be associated with keyword – launchBrowser(), action to write in a textbox with keyword – writeInTextBox(webElement, textToWrite) etc.

• The code to perform the action based on a keyword specified in external file is implemented in the framework itself.

• In this way, the test steps can be written in a file by a person from non-programming background once all the identified actions are implemented.

A hybrid framework is a combination of one or more frameworks. Normally it is associated with combination of data driven and keyword driven frameworks where both the test data and test actions are kept in external files (in the form of table).

• A datadriven framework is one in which the test information is put in external files like csv, excel an d so forth separated from test logic written in test script files. The test data drives the test cases, i.e. the test methods run for each set of test data values.

• TestNG provides inherent support for data driven testing using @dataProvider annotation.

Nodes are the machines which are attached to the selenium grid hub and have selenium instances running the test scripts. Unlike hub, there can be multiple nodes in selenium grid.