Explore topic-wise InterviewSolutions in .

While executing the test cases, the test case may fail. The way while executing the test case manually we take a SCREENSHOT and place it in RESULT repository, same way things can be done by using Selenium WebDriver.

We may need to capture SCREENSHOTS using Selenium WebDriver in scenarios -

1. Application issues
2. Assertion Failure
3. Difficulty to find WebElements on the web page
4. Timeout to find WebElements on the web page

Selenium is having an INTERFACE named TakesScreenshot to take the screenshot. This Instance has one method getScreenShotAs() will be used to take a screenshot during test execution and saves that screenshot at the desired location that we provide in the code.

Syntax to capture and save the screenshot is -

For ex. File screenshotFile = ((TakesScreenshot)driver).getScreenshotAs(screenshot1.png);

Syntax to store it in our local drive is -

When the script fails, to know where was the error in script capture a screenshot of the web page when the test case fails. By seeing screenshot, We can easily identify where exactly the script is failed.

To take a screenshot of the failed test, we will place the entire code in try-catch block by placing the test steps in a try block and then screen capture statement in the catch block. In try block, if a test step fails then it goes to the catch block and captures a screenshot of the web page.

package software testing material;

Object Repository is a centralized location where you can STORE the object information. Object repository acts as an interface between Test script and application in identifying the objects during the execution.

The collection of web elements belonging to AUT that is Application Under Test ALONG with their locator VALUES is termed as Object Repository. During execution whenever an element is required in the script, locator value is populated from the object repository. Instead of hard coding locators in the script object repository can be used and locators can be stored in a central location. Objects are stored in an excel sheet or XML file which populates inside the script whenever required.

It is always recommended using an external file for object repository rather than hard coding the objects and its properties directly into our code and Reason is as it reduces the maintenance effort and provides a positive Return on investment. If any of the object properties change within the application under test, we can easily change it in external object repository file, instead of searching and doing updates for that object individually in the code.

Before creating an object repository pre-requisite is project is CREATED and Selenium jars are added.

1. Create a new file with extension .properties

For example, object_repo.properties

To create new file right click on project> New > File

2. Select the parent folder and specify file name & extension.

3. Now Double click on file> File will open in Edit mode

As object repository works on KEY and Value pair, you will specify Keys based on project and values we will give locator value.

Let us take XPath for username, password and login button for facebook login page.

1. facebook.login.username.xpath=.//*[@id='email']
2. facebook.login.password.xpath=.//*[@id='pass']
3. facebook.login.Signup.xpath=.//*[@id='loginbutton']</span>
4. Write Selenium script and use the same in the script

Selenium is an automation tool allow us to record and PLAYBACK application under test without having knowledge of scripting by using selenium IDE. Selenium IDE uses Selenese language to write test cases in different programming languages like Java, C#, PHP, Perl, Python, Ruby, etc. Resulting tests can be run on against different browsers.

Debugging is the process of identifying and fixing the errors that may be present in the class. It is important to debug the code in order to remove the errors so that the application will run as expected.

The following are the ways to debug the script.

• Insert a breakpoint from where you want to execute step by step
• Run the test case
• At the given breakpoint, execution will be paused
• To proceed with the next step, click on the Blue button
• To run commands at a time, click on the run button

To make the debugging process more robust, we can install and use Power Debugger add-on.

• Step 1: OPEN Firefox browser, search for Power Debugger in Google and click on https://addons.mozilla.org/en-US/firefox/addon/power-debugger-selenium-ide/ link.
• Step 2: Add-ons page appears on the web. Click on Add to Firefox button.
• Step 3: Open ‘Selenium IDE’ and you can see a new icon, “Pause on Fail” on the recording toolbar. Click it to turn it ON. Clicking it again would be TURNED to “OFF”.
• Step 4:  We can use breakpoints to understand the error during the execution. To insert a breakpoint on a particular step, “Right Click” and select “Toggle Breakpoint” from the menu options.
• Step 5: After inserting the breakpoint, a particular step will be displayed with a pause icon.
• Step 6: When we execute the test script, the script execution will be paused where the breakpoint is INSERTED. This pause will help the user to evaluate the value/presence of an element when the execution is in progress.

TestNG is a testing framework that is developed as inspiration from the most popular JUnit framework used for java programming language. TestNG framework is introduced to OVERCOME the limitations of the JUnit framework. Most of the organizations are using the TestNG framework because of its advantages and additional supporting FEATURES.

Features of TestNG framework:

TestNG supports more productive and advanced features and it is easy to use. Let’s check which new features are available in the TestNG framework.

• It supports for parameters
• It supports testing of dependent methods
• Configuring the test is flexible
• It supports more powerful execution model
• It embeds BeanShell which further makes it more flexible.
• It is having more elegant WAYS of handling parameterized tests with data provider concept.
• It supports multiple instances for the same test class
• It becomes more extendible as different tools and plug-ins like Eclipse, Maven, IDEA is supported. 
• TestNG framework allows generating reports in XML and HTML format.
• TestNG is designed to cover unit testing, integration testing, functional testing and end to end testing.

Advantage of TestNG v/s JUnit

1. TestNG have annotations that are easy to understand over JUnit
2. In TestNG, it doesn’t require  constraints like to declare @BeforeClass and @AfterClass, which needs to be DONE in JUnit
3. TestNG allows executing test cases in a group, which is not possible in JUnit.
4. TestNG support three additional setup: @Before/AfterSuite, @Before/AfterTest and Before/AfterGroup
5. TestNG do not require to extend any extend
6. TestNG allows us to define dependent test cases, each test CASE is independent of others.
7. Parallel test case execution is possible in TestNG.

Navigation commands enable selenium to open a new web PAGE URL, navigate to other page links available on the web page by clicking on that LINK or can navigate to Back or FORWARD or can refresh the webpage content again.

Following are some types of navigation commands:

1) navigate().to(): This command is same like get() command, it opens a new BROWSER and will find the URL specified by the user.

e.g. driver.navigate().to(“https://google.co.in/”);

2) navigate().forward(): This command is used to navigates to next page travelled by the user and is available in the browser history.

e.g. driver.navigate().forward();

3) navigate().back(): This command is used to navigates to back page user travelled from and is available in the browser history.

e.g. driver.navigate().back();

4) navigate().refresh():This command is used to refresh the CURRENT web page. All the web page content get reloaded again

e.g. driver.navigate().refresh();

In the computing world, the same-origin policy is at the most important concept in the security model available for web applications. This policy permits SCRIPTS running on the pages that are originating from the same source or site. Origin is a combination of schemes, hostname and port number, to access each other’s DOM with no specific restrictions but at the same time, it prevents access to DOM on different sites.

The Same-origin policy also applies to an XML, HTTP request and to web socket. This mechanism bears a particular significance for modern web applications that are using user logins are extensively dependent on HTTP cookies to maintain user sessions that are authenticated, as servers act based on HTTP cookie information to reveal sensitive information or take state-changing ACTIONS. A strict separation between content provided by the unrelated sites must be MAINTAINED on the client-side to prevent the loss of data confidentiality or integrity.

Policies could have different specifications; all browsers are having an implementation of same-origin policy as it is an unavoidable security concern. An algorithm is used to evaluate the origin of the specified URL. For absolute URL, origin contains protocol, host and port number. If the URL is not absolute, then a unique identifier is used. Any two resources are considered as from the same origin only if all of the values are exactly the same.

Same Origin policy prevents JAVASCRIPT code from accessing elements from a domain that is different from where it was launched. To overcome the Same-origin policy, Selenium RC was introduced. Prior to Selenium RC, testers REQUIRE to install local copies of both Selenium Core and the web server containing the web application being tested so they would belong to the same domain.

There are two ways you can upload file in selenium WebDriver, one is using SendKey method when there is text box AVAILABLE to enter the file’s name and second is using AutoIT Script tool when there is no text box to enter the file’s name.

• Upload file using SenKey() method –
  • First, LOCATE the text box and then using SendKey() set the file path and click on the SUBMIT button.

Syntax is –

• Upload using open-source AutoIT Script tool
  • First, download and install the AutoIT Script tool (http://www.autoitscript.com/site/autoit)
  • Open Autoit tool -> SciTE Script Editor
  • Paste below code in editor and save it with .exe extension say test.exe

WinWaitActive("File Upload"); Name of the file upload WINDOW (Windows Popup ame: File Upload)

• Compile code and then build tools menu of AutoIT editor
• Paste below code in Java editor and execute test

Now a day, many web APPLICATIONS have the functionality to drag an element and drop it on a defined area.

There are two METHODS in Actions class which SUPPORTS drag and drop -

1. Actions.dragAndDrop(Sourcelocator, Destinationlocator)

Here we pass two parameters, first "sourcelocator" is the element we need to drag. The second PARAMETER is "Destinationlocator" which is the element on which we need to drop the first element.

1. Actions.dragAndDropBy(sourcelocator, x-axis pixel of destinationlocator,y-axis pixel of destinationlocator)

Here we pass three parameters, first "source locator", the second is x-axis pixel VALUE of the 2nd element on which we need to drop the first element and third is y-axis pixel value of the 2nd element.

Ex. 

In some scenarios, you might NEED to do the right click action/context on an element to perform some actions. Use Selenium WebDriver class Actions to work on Mouse and Keyboard Actions. Selenium has a built-in capability to handle various types of keyboard and mouse events. In order to perform action events, we need to use org.openqa.selenium.interactions Actions class,  user-facing API for performing complex user gestures. Instead of USING Keyboard or Mouse directly, you can use the selenium actions class.

Let us see the scenario to automate

1. First launch the web browser and open the facebook application
2. Then find the required element and do right click on the element SAY LOGIN button

In selenium, we can click on the Login button in different ways -

1. Navigate to login button. Once control is on the login button perform click() ACTION.

package clicklogin;

2. ANOTHER way to perform click on Login button using action class

3. Third way is PRESS Enter key

The desired capability stores the browser properties like browser NAME, browser version, the path of the browser driver in the system, etc in a series of key/value pairs, to determine the behaviour of the browser at RUN time.

You can also use the Desired capability to configure the driver instance of Selenium WebDriver like FirefoxDriver, ChromeDriver, InternetExplorerDriver.

Every Testing scenario is executed on a specific testing environment and this testing environment can be a web browser, Mobile device, mobile emulator, mobile simulator, etc.

The Desired Capabilities Class TELLS WebDriver, which environment you going to use in the test script.

The setCapability method of the DesiredCapabilities Class can be used in Selenium Grid to perform a parallel execution on different machine configurations.

Desired capability is used to set the browser properties, Platform Name that is used when executing the test cases.

In the case of mobile automation, we perform the tests on different mobile devices, the Mobile Platform ex. iOS, Android Platform Version Ex. 3.x,4.x in Android can be set.

Desired Capabilities are more USEFUL in mobile application automation, where the browser properties and the device properties can be set. And in Selenium grid to run the test cases on a different browser along with different operating systems and versions.

Example-

You often get ElementNotVisibleException when you execute selenium scripts when WebDriver locate WEB element on the current webpage but the element is not visible on the screen.

There are many reasons that accumulate for this exception. Below are the reasons for ElementNotVisibleException –

Not locating correctly

• When your locator is incorrect, selenium WebDriver throws “NoSuchElementException”. Exception means, WebDriver is able to locate elements, but the DESIRED element is not visible.
• Your locator may be wrong in case of a nested web element. A web element inside web element is called as the nested web element.

Solution:

Locate correct and specific element.

The desired element is overlapped by another web element

• Many applications nowadays use toaster MESSAGES. A toaster message stays on screen for 3 seconds.

• When you click on any button or link, you might get the above exception as button or link is overlapped by toast message. Webdriver will not be able to click on button or link and throws a perfect exception stating other elements would receive the click.

Solution:

• Wait till toast message disappears. You must use the wait property provided by selenium.

Ajax calls

• AJAX  allows web pages to be UPDATED asynchronously by exchanging data with a web server behind the scenes. It is possible to update parts of a web page without reloading the whole page. Selenium wait when the whole page is loading but can not recognize loading through AJAX calls. If you perform any action on a web element that is still loading because of AJAX calls when AJAX calls in progress, you may get NoSuchElementException or Element is not clickable(If action is click)  or Element is not visible exceptions.

Solution:

• Wait till the AJAX call is complete by using selenium wait property.

Webdriver is unable to auto-scroll to the desired element

• If your web page has a vertical scroll bar and you need to perform an action on web element which shows up in the visible area when a user scrolls down. Webdriver mostly scrolls down to element and perform desired OPERATIONS but sometimes, web driver is not able to do so. In this case, you may get an exception.

Solution:

• Scroll to the element using javascript or Actions class so that the element is visible on the screen.
• By using selenium wait property.

WebDriver has various wait commands that help to overcome issues due to variation in a time lag. Web driver checks whether an element is present or visible or enabled or clickable etc. 

The Fluent wait is one of the Explicit waits. In Fluent wait, you can DEFINE the maximum AMOUNT of time for a condition and frequency with which to CHECK the condition before throwing an exception.

In short, fluent wait tries to FIND the web element repeatedly at regular intervals of time until the timeout or till the object GETS found. Mainly FluentWait command is used when web elements are visible in few seconds and sometimes take more time than usual. Two main components of fluent wait are - Timeout value and polling frequency

FluentWait syntax is -

WEBDRIVER has various wait commands that help to overcome issues due to variation in a time lag. WebDriver checks WHETHER an element is present or VISIBLE or ENABLED or clickable etc. 

The explicit wait tells the WebDriver to wait for certain conditions (Expected Conditions) or wait till the maximum time exceeded before throwing an exception.

The explicit wait is an INTELLIGENT wait but can be applied only on specified elements. As explicit wait waits for dynamically loaded Ajax elements, it is a better option than implicit wait. We need to provide “ExpectedConditions” along with Explicit wait.  

Syntax:

Below is the list of Expected Conditions used in Explicit Wait

1. alertIsPresent()
2. elementSelectionStateToBe()
3. elementToBeClickable()
4. elementToBeSelected()
5. frameToBeAvaliableAndSwitchToIt()
6. invisibilityOfTheElementLocated()
7. invisibilityOfElementWithText()
8. presenceOfAllElementsLocatedBy()
9. presenceOfElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. titleIs()
14. titleContains()
15. visibilityOf()
16. visibilityOfAllElements()
17. visibilityOfAllElementsLocatedBy()
18. visibilityOfElementLocated()

Before throwing and exception IMPLICIT wait tells WebDriver to wait for a CERTAIN amount of time. WebDriver will wait for the element based on the time we set before it throws an exception. We need to set some wait time to make WebDriver to wait and default setting is 0 (zero). Implicit Wait is in place till the browser is open. Based on time fixed for the implicit wait, the same wait time will be applied to all elements for search.

Syntax:

Two PARAMETERS required for Implicit wait are time as an integer value and second is time measurement in terms of seconds, minutes, milliseconds, microseconds, days, hours, ETC.

Selenium WebDriver has predefined method CLEAR() which is used to clear the text entered or displayed in the text fields. Some times default text is displayed in the text box or sometimes due to cookies stored pre-populated text is displayed in a text box and we need to clear that text before entering NEW text otherwise we might get the WRONG result. To AVOID test failure it is always a best practice to clear text before entering new text.

driver.findElement(By.id(“id Value”)).clear();

Let us see the code for clear text. We will use google.com for our reference. In this, we are sending some text first and then clear it.

Additional information about an HTML is stored in Attributes and comes in pair name =”value”. In <div class=”my-class”></div> example div is tag and class is attribute with value ‘my-class’. The property PRESENTS an attribute in the HTML DOM tree. In the above example, the attribute would have a property named className and value my-class. HTML defines attributes and DOM defines properties. Attributes may have 1:1 mapping with property or may not have. The ID is an example of 1:1 mapping. Attributes are stored in HTML text document and properties are in the HTML DOM tree. Attributes carry initial default value and the attribute does not change whereas HTML properties can change.

To verify test cases, during automation we need to retrieve values of attributes or properties of web elements.

In case of a bus ticket booking application,  Colour of the available seat colour is green and BOOKED seat colour is red. To book the ticket first we need to check whether a seat is available or not. And to test this, we need to fetch colour attribute value using the script and based on output value we need to perform further operations.

To fetch attribute value, selenium WebDriver has predefined getAttribute(value) method which returns the value of the attribute of the web element as a string. If the attribute exists, getAttribute method returns value of the property with the given name, and if it does not exist then returns value of the attribute with the given name.

Please NOTE, when the given name is “class”, then “className” property is returned and when given name is “readOnly”, the “readOnly” property is returned.

To use getAttribute() method on a specific element, first, locate the web element and then call getAttribute() method on it by specifying the attribute.

Below is the code explaining getAttribute() method –

Selenium has a built-in capability to handle various types of keyboard and mouse events. In order to perform action events, we need to use org.openqa.selenium.interactions Actions class,  user-facing API for performing complex user gestures. Instead of using Keyboard or Mouse directly, you can use the selenium actions class.

Syntax to create an object ‘action’ of selenium action class –

• Actions action – new Actions(driver);
• To focus on element -
• action.moveToElement(element).perform();

Here element is the web element we have CAPTURED and perform() method is used here to execute the action.

To click on Element -

• Action.moveToElement(element).click().perform();
• Here click() method is used to click the element.
• Let us see methods available with Selenium Actions class -

Keyboard Events Using Selenium Actions Class API:

• sendKeys(keysTo Send  sends a series of keystrokes onto the element
• keyDown(theKey): Sends a keypress without RELEASE it. Subsequent actions may ASSUME it as pressed. (example: Keys.ALT, Keys.SHIFT, or Keys.CONTROL)
• keyUp(theKey): Performs a KEY release

Mouse Events Using Selenium Actions Class API:

• click (): Simply click on an element
• doubleClick (): Double clicks on Element
• contextClick() : Performs a context-click (right-click) on an element
• clickAndHold(): Clicks at the present mouse location (without releasing)
• dragAndDrop(source, target): Clicks-and-hold at the source location and moves to the target location of the element before releasing the mouse. source – element to grab, target – element to release
• dragAndDropBy(source, xOffset, YOFFSET): Invokes click-and-hold at the source location, shifts by a given offset, then frees the mouse. xOffset  is to shift horizontally and yOffset is to shift vertically
• moveByOffset(x-offset, y-offset): Shifts the mouse from its current position or 0,0 by the given offset. x-offset – Sets the horizontal offset (negative value – shifting the mouse to the left), y-offset – Sets the vertical offset (negative value – shifting the mouse to the up)
• moveToElement(toElement): It shifts the mouse to the center of the element
• release(): Releases the depressed left mouse button at the existing mouse location

In testing, it is very much necessary to store test result DATA to prove the certain test is passed/failed or functionality is covered or not and you can take SCREENSHOTS as test result or proof, which can be used for reference later. The same way we need to take screenshots as proof in automation testing also. During automated testing of continuous application flow, you might want to capture a series of screenshots. Selenium WebDriver has a nice little utility MultiScreenShot to capture multiple screenshots. This utility ALLOWS you to take a screenshot of individual elements and minimize the browser.

We will see how to setup MultiScreenShot utility with selenium WebDriver and capture multiple screenshots. We will use Google.com for the explanation.

• First, download the MultiScreenShot jar file.
• Add jar in your Selenium Webdriver project by adding it to Java Build Path.
• Now import the package in your class file.
• Let us create an object to use MultiScreenShot. Pass two arguments that are the path to SAVE screenshot and class name to create the folder and save the screenshot inside that.
  Example: path=C:UsersxxxxxxDesktopTestMultiScrShot
                   className=ScreenShots

Full page screenshot is taken when you call the method and this method accepts WebDriver object as an argument.

Example: multiScrShot.multiScreenShot(driver);

Screenshot of elements on a page is taken when you call method and method accepts WebDriver object as argument and WebElement object

Example: mShot.elementScreenShot(driver, driver.findElement(By.id("search-submit")));

Minimize the browser window when the browser window is maximized. No argument is required to pass.

Example:  multiScrShot.minimize();

Data is very important and critical information to run automation successfully. Data can be in different forms to serve different purposes.  For example in automation, input data includes test cases, and it could be test data that feeds into test cases as parameters.

Selenium supports Excel, CSV, XML, JSON, SQL, YAML data types for automation.

1. Excel Data.

Excel is a popular data format used widely in automation. It can store test cases as well as test data.

Excel format is not only flexible but also support Create/Delete/Update/Delete (CRUD) operations also. All language that Selenium supports have ready-made LIBRARIES to access and manipulate excel data.

2. XML Data.

An XML document is in a format readable by both humans and machines. XML is a web standard and faster than Excel in reading or WRITING data. There are built-in or third-party XML parsers available to manage the data. XML has a unique feature to search specific elements called XPath. Xpath is a known term in Selenium which traverses the DOM of a web page.

Many times Excel and XML are used together in Selenium automation projects. You can write the test cases in Excel and create a macro to convert them in XML format. The automation suite reads the test cases from XML and executes them.

3. SQL Data.

SQL data is customizable and enables fast data access. It stores both the test cases and configuration or settings as required.

Separate database software like MySQL/MongoDB/SQL/Oracle is required to make it work and install any of this software to prepare a new setup which is an additional overhead for the automation engineers.

4. CSV Data.

CSV that is comma-separated-values, is the simplistic way of organizing test data in tabular format. CSV data is a text file with extension .csv and it represents a sequence of rows and columns delimited by commas. Every row of CSV file is a record while every column mapped to a field.

As most programming LANGUAGES come with standard libraries to read/write text files it is trivial to access CSV. Excel supports this TYPE of data and can handle it the same way.

5. JSON Data.

JSON (JavaScript Object Notation) supports a light-weight data interchange format. JSON data is compact and fast and we can use it to represent the test data replacing Excel and XML formats. For large data SIZE, JSON would deliver better performance.

6. YAML Data.

YAML(YAML Ain’t Markup Language) is a human-readable language for data serialization. For holding configuration this type of data format is ideal. YAML is a superset of JSON language and stores both JSON and XML data within itself.

Links or URLS which are not reachable or FUNCTIONING are broken links due to some error.

There are different status codes for HTTP which are having different purposes. 2XX is valid request status and the URL will always have status 2XX. Status 4XX and 5XX are for invalid HTTP request out of which 4XX status code is for client-side error and 5XX status code are for server response error.

It is not possible to confirm that the link is working or not till we click on the link and confirm it.

It is always GOOD practice to make sure that there are no broken links because the end-user should not land into an error page.

You can not check all links manually, because each web page may have a large number of links & manual process has to be repeated for all pages. It will be a tedious task.

With Selenium, we can automate the process.

• First, collect all links on the web page BASED on a tag.
• Then send an HTTP request for the link and read the HTTP response code.
• Based on the HTTP response code determine whether the link is valid or broken
• Repeat this for all the links CAPTURED.

Selenium is limited to browser testing. To access databases using Selenium WebDriver we need to use JDBC that is Java Database Connectivity.  JDBC is a SQL level API to execute SQL commands and is responsible for the connection between Java and different databases. So use JDBC Driver to connect to the Database with Selenium when using Java as a programming language.

To connect to the database first download the JDBC jar FILE and add it to your project.

Also you need database URL with port, user ID and password. Syntax in order to make connection to the database is -

Where, URL format is  jdbc:<dbtype>://<host>:3036/db_name" and  <dbtype>- database driver. To connect to oracle database <dbtype> will be "oracle"

So for Oracle database with NAME ‘demo’ URL will be jdbc:oracle://<host>:3036/demo

So code for database connection will be

You need to load JDBC driver and code is

Once connection is established you need to execute queries and for that you need to declare STATEMENT object to send queries

Now use the executeQuery method to execute the SQL queries

Store the result of executed query in the ResultSet Object

TestNG is an open-source testing framework inspired by JUnit and NUnit but presenting some new functionality that makes it simply easy, effortless, and powerful to use where NG of TestNG stands for Next Generation. It is same as JUnit but it is more robust than JUnit. To make execution more efficient and powerful more functionality is added. It is very much DATA-Driven but is powerful than JUnit. Most of the negative TRAITS of the older framework are removed from TestNG and it gives developers the ability to write more FLEXIBLE and powerful tests with the help of annotations, grouping, sequencing and parameterizing.

Advantages of TestNG are -

• Can generate logs
• Due to Annotations code is efficient and easy to manage
• Ability to generate execution Reports in HTML
• Can be Grouped & Prioritised tests easily
• Parallel testing is possible in TestNG
• Data Parameterization is supported
• Due to annotation testing time reduced considerable testing time reduce considerably
• Scheduling of test cases can be done properly
• Can use a data-driven approach by USING a data provider
• Proper control over test execution is possible

Below are the few methods that help in the easy execution of test scripts required for Robot class implementation.

1. KEYPRESS()
2. KeyRelease()
3. MouseMove()
4. MousePress()
5. MouseRelease()

Let us understand these methods in details -

1. KeyPress() - Use this METHOD when you want to PRESS any KEY

Example : robot.keyPress(keyEvent.VK_UP); will press UP key on the keyboard.

1. KeyRelease() - Use this method to release the pressed key on the keyboard.

Example: robot.keyRelease(keyEvent.VK_CAPS_LOCK); will release the pressed caps lock key on the keyboard.

1. MouseMove() - use this method when you want to move the MOUSE pointer in the X and Y coordinates.

Example : robot.mouseMove(coordinates.get.X(),coordinates.get.Y());will move the mouse over X and Y coordinates.

1. MousePress() - use this method to press the left button of the mouse.

Example - robot.mousePress(InputEvent.BUTTON1_MASK); will press the mouse button

1. MouseRelease() - Help this method in releasing the pressed button of the mouse.

Example - robot.mouseRelease(InputEvent.BUTTON3_DOWN_MASK); will release the right click of the mouse.

Let us see the code on how to declare robot class -

In some automation scripts, there is a need to use mouse or keyboard actions to interact with OS like Alerts, download pop-up, Print pop-up, etc. and Selenium Webdriver cannot handle these OS pop-ups or applications.

A Robot is a class in Selenium and is used to generate NATIVE system INPUT events for test automation, where you need control over the mouse and keyboard. To handle the OS POPUPS which WebDriver does not handle, the Robot class was introduced.

The MAIN purpose of ow Robot class is to assist automation testing for Java platform implementations. In other words, the Robot class provides control over mouse and keyboard devices.

This class is easy to implement and easily integrate with the automation framework.

Let us see the importance of the Robot class -

1. Using Robot class you can easily upload a file
2. Robot class handle the mouse and keyboard functions
3. pop-ups can be HANDLED easily with Robot class

Continuous Integration is a technique which regulates the development process by automating the BUILD and testing code on every commit made to the version control. Continuous Integration makes sure that NEW changes do not have any adverse effect on the build and existing functionality is not affected. In the case of a failed scenario, everyone including the one responsible for the changes will know about the FAILURE without delay. With this timely reporting, developers find fair time to fix the issues and get prompt feedback.

Continuous Integration encourages best practices amongst developers by allowing them to merge their changes with other's code before checking into a shared repository. On time code integration eliminates changes of conflicts, duplication of functionality.

CI suggests using a version control system that supports Git workflows for intelligent branching. CI proposes having the main BRANCH that keeps the stable code that can be used to deliver build at any time. At the same time developer can create transient features branches to start his work without interrupting others. Developers need to sync his code with Main Branch at regular intervals. On feature-complete, a developer should merge his code into the main branch after verification

The TWO most commonly used network protocols are HTTP and HTTPS. There are multiple ways to handle both protocols in Selenium.

HTTP protocol -

No Authentication - When a website is using HTTP protocol and does not require any authentication, it is easy to handle

WebDriver driver = new ChromeDriver();

driver.get("http://destination-url/");

Basic authentication - Many WEBSITES apply basic authentication scheme before allowing access to the home page. You can handle basic authentication in three ways-

i) Using WebDriverWait and Alert classes to implement basic authentication for HTTP.

ii) pass user/pass pair within the HTTP URL as a parameter to WebDriver's Get method.

iii) Setting up browser preferences using the Selenium's profile classes.

HTTPS protocol - HTTPS is a secured protocol of HTTP and it encrypts communication exchanged between the web server and the browser. HTTPS protocol uses an SSL certificate that downloads onto the browser on initiating the first request. SSL certificate has a public key for encrypting the data transfer from client to server.

In short, we need to handle the SSL certificates in Selenium. To manage SSL in different browsers you need to use different approaches.

Handle SSL in Firefox - In firefox SSL is enabled using Selenium Profile APIs.

First load the profile of RUNNING browser instance.

Set the following properties to avoid security exception while opening the HTTPS site 

Now create Firefox driver instance using profile object.

Handle SSL in Chrome - Chrome need to set SSL options via desired capabilities of selenium WebDriver.

First prepare DesiredCapabilities instance

Handle SSL in IE - In IE SSL is managed with two different methods.

i) Native JavaScript CODE -

driver.navigate ().to ("javascript:document.getElementById('overridelink').click()");
ii) DesiredCapabilities Class -

Maven builds the code and manages dependencies on the fly. Also due to its ability for SUPPORTING deployments Maven is used wide-spread. Maven makes a lot of post-development tasks easy. There are a bunch of other tools you can use instead of Maven.

• Ant - Ant (Another Neat Tool) is a command-line tool written in Java and uses XML to build modules, define TARGETS and specify dependencies.
• IVY - IVY is a build tool from Apache and is an EXTENSION to Ant. IVY helps in managing the external dependencies during development. IVY provides a way of adding dependencies to the classpath and packaging them with the APPLICATION. IVY is a lightweight alternative to Maven.
• Gradle - Gradle an open-source build tool automates the build PROCESS taking over Ant and Maven tools. Gradel uses domain-specific language instead of XML templates for defining the project configuration. The groovy syntax is followed in a domain-specific language.

Gradel suggests a polyglot build system that integrates the project with different technologies and programming languages. Gradle makes version management easier than Maven with the help of dynamic versioning.

We always wish to TEST our software using different sets of data to make sure software works properly under a different set of data.

Parameterization is the technique USED to define values in the testng.xml file and send these values as parameters to the test case. Parameterization is useful when you want to PASS multiple data to different test environments. We need to pass multiple data to the application at runtime. Below is the CODE in which empName is annotated as a parameter

To pass the parameter value using testng.xml, USE the 'parameters' tag. Look at the below code -

Selenium does not support report generation and test case management, we use the TESTNG framework with selenium to support these features. TestNG is more advanced than JUnit and implementation of annotations is easy. 

The test suite is not defined in TESTING source code and it is represented in an XML file because the suite is a COLLECTION of test cases and an execution is the feature of the test suite.

To execute test cases in a suite or group of test cases, you need to create a testng.xml file. The testng.xml file contains the NAME of all classes and methods that needs to be executed as a PART of execution flow.

Advantages of using testng.xml file are -

1. The execution of multiple test cases from multiple classes is allowed.
2. Parallel execution is allowed.
3. Execution of test cases in groups, where a single test can belong to multiple groups is allowed.

Every website is comprised of n number of technologies that are USED in the backend and frontend. Three major technologies used for the front end and in the rendering are HTML5, CSS3, and JavaScript.

Every browser has a different rendering engine to compute these three technologies. Chrome uses Blink, Firefox uses GECKO and IE uses edge HTML and Charka. Because of these rendering engines, the same website renders complete differently in all these different browsers and that is the reason why you need cross-browser testing. To ensure the website works fine and functions the same across different browser versions and on different operating systems, cross-browser testing is required.

Reasons for why cross-browser testing is required are -

1. To ensure browser COMPATIBILITY with different operating systems.
2. To ensure image orientation on different browsers.
3. Different orientation of Javascript on each browser can cause an issue.
4. To check font size mismatch or font not rendered properly.
5. To check compatibility with the new web framework.

To execute scripts two important LIBRARY packages DesiredCapabilities object and RemoteWebDriver object are required. DesiredCapabilities library is used to set browser type and the OS of Node. Use the below code to import the DesiredCapabilities object.

The RemoteWebDriver object is used to select the Node on which TEST will be executed. Use the below code to import RemoteWebDriver object.

You can mouse HOVER on the logos of browser present in the Selenium Hub console to get the details like browserName and platform of the Node.

Use below code to setup grid

Here the test is divided into three test annotations @BeforeTest, @Test, and @AfterTest. In @BeforeTest, DesiredCapabilities and RemoteWebDriver objects are used to configure Node. In @Test directed Node to navigate to nikasio.com's home page.In @AfterTest, directed Node to quite the browser instance.

On execution, you will get below output.

May 18, 2018 4:15:07 PM org.openqa.selenium.remote.ProtocolHandshake createSession

• INFO: Detected DIALECT: OSS
• PASSED: simpleTest

Nodes are host machines on which the TESTS are RUN. These tests are launched by the Hub. Hub can launch ONE or more nodes on remote machines or on the same machine where Hub is located. Node executes tests you loaded on the hub.

To configure nodes, you need to download the Jar files on the Node machines and place it on any directory of CONVENIENCE. Open windows command prompt and execute below command-

java-DWebDriver.chrome.driver=C:chromedriver.exe -jar selenium-server-standalone-3.141.59.jar -role node -hub http://192.168.2.11:4444/grid/register 

To set a Node on the same machine as you Hub, you need to open another command prompt other than Hub prompt.

• DWebDriver.chrome.driver=C:chromedriver.exe is used to set the browser driver path. 
• role node flag used to set a particular host machine as a node.
• hub http://192.168.2.11:4444/grid/register directs Node to connect with Hub using Hub's IP address. If you want to launch a Node on the same machine as your HUb, then you can specify ‘-hub http://localhost:4444/grid/register‘ in the command.

To check Nodes are registered, open and browser and navigate to http://localhost:4444/grid/console. Once Selenium Grid is CONFIGURED, you can proceed with the test script execution on Nodes.

Before proceeding further with configuration make sure Java is installed on your system and environment variable is set. Now to configure Hub, first, you need to download the SELENIUM Server JAR FILE 'selenium-server-standalone-3.141.59.jar' from Seleniumhq's website.

Place this Jar file in an appropriate directory (says c:/Selenium Server. )

Open windows COMMAND prompt and navigate to the directory where Jar file is stored.

for example c:>Selenium Server

Now EXECUTE below command -

Where selenium-server-standalone-3.141.59.jar is the downloaded jar file. -role flag is used to set a host machine as Hub. One thing to keep in mind is Hub will be up and running as long as the command prompt is open. By default, the selenium grid uses 4444 port for web interfaces. To check whether the Hub is up and running open browser and navigate to http://localhost:4444 and you will see below UI.

We know Selenium GRID is ONE of the important tools of Selenium suite and it functions on Node and multiple hub basis. LET us see what is Hub and Node? and how it works?

• The Hub - There is only one Hub called as master and that is a central point of that grid setup. Any grid setup will have only one Hub. Tests that need to be executed should be loaded on HUB. Tests that are loaded on Hub will be executed only on Nodes. Any host machine can be configured as Hub and will co-ordinated test execution on other hosts.
• The Nodes - Nodes are the machines on which tests are run. Hub will LAUNCH these tests. The Hub can launch one or more Nodes on remote machines or on the same machine where Hub is located. Each node can have DIFFERENT operating systems and different versions of the same browser or different browsers.

You need to configure Hub first and the register nodes with Hub to execute tests.

One of the important tools in the SELENIUM suite is Selenium Grid. Selenium grid has the capability of co-ordinating WebDriver tests or RC tests that can run on MULTIPLE browsers simultaneously. Selenium Grid can initiate WebDriver tests or RC tests on different operating systems. Selenium Grid even initiates or EXECUTES tests hosted on different machines. There can be only one hub and it will be a central part of the Selenium Grid setup and nodes are test machines on which tests are run.

Let us see how it works? Grid hosts a Hub-Node architecture. Here there is one Hub acts as the master and one or more nodes that ACT as slaves.

Consider you have 100 tests that are required to be executed simultaneously on different machines in different combinations of operating systems and browsers. Each MACHINE has a different OS and inside OS, the test is executed on different browsers. This will save a lot of your execution time.

Many web browsers are available and used nowadays. Users may use FIREFOX, or Safari, or Chrome, or Internet Explorer browser for reading. Users may use different versions of the browsers and also may be running browsers on any OS like Windows, or Mac, or Linux.

To help users get the best user experience, you need to go extra miles and test Web application on different browsers along with different platforms. You need to test applications on different browsers and OS. You need to put extra effort and spend TIME testing your web application on every possible OS and available browser. Is it possible and feasible? Now how to make it possible? Here Selenium grid FITS well and saves your time and energy.

Now the question is, Is it possible to set up selenium grid infrastructure using local systems? It is challenging to MAINTAIN Selenium Grid with all required browsers and operating systems and for that multiple online platforms PROVIDE an online Selenium Grid which you can access to run selenium scripts.

We can configure our WebDriver test or WebDriver test suites for software testing project in testng.xml file. If we have two/multiple classes in test suite we can run those classes in the same test as well as two different tests too. Let's take a simple example here:

Create 3 classes under project = TestNGOne and package = TestNGOnePack as below.

BaseClassOne will be used for initializing and closing WebDriver instance,

ClassOne and ClassTwo will be used as test classes.

1. BaseClassOne.java:

The above class will be base class and be used to initialize and close the WebDriver instance. 

1. ClassOne.java:

Above ClassOne is inherited or created from BaseClassOne.

1. ClassTwo.java:

Above ClassTwo is also inherited or created from BaseClassOne.

Configure testng.xml to run two classes in one test:

Copy the below-given lines in the testng.xml file and run it as TestNg Suite.

When execution is completed, View execution results report.

Configure testng.xml to run two classes in two tests:

Now if we want to run both classes as SEPARATE test then we have to configure testng.xml file as below

Here, "ClassOne" is included in 'Test One" test and "ClassTwo" is included in 'Test Two" test. Now run below given testng.xml file and verify results.

After comparing both results. In the 1st example, Both classes are executed under the same test but in the second example, both classes are executed under separate tests. This way you can configure the testng.xml file as per your requirement.

Selenium Webdriver is itself an API and it’s an interface. Selenium hierarchy contains two WebDriver - Remote WebDriver and Selenium WebDriver. Remote WebDriver is a class that implements the Selenium WebDriver interface whereas browser classes ChromeDriver(), FirefoxDriver() and etc. extend the Remote WebDriver. There are many APIs and methods in Selenium and following are some as follows:

 1. Navigation Commands:

• navigate().to(URL) - To navigate to a particular URL.

Driver.navigate().to("http://qatechhub.com");

• get(url) - To navigate to a particular URL.

Driver.get("http://qatechhub.com");

• navigate().BACK() - Takes us  back in the browsing

Driver.navigate().back();

• navigate().forward() - Takes us  forward in the browsing

Driver.navigate().forward();

• navigate().refresh() - reloads the page.

Driver.navigate().refresh();

2. Resizing Windows:

• Set Size - Sets the size of the window; the unit used is pixels.
• Dimension d = new Dimension(640, 640);
• Driver.manage().window().setSize(d);
• Maximizing the Window - To set the size of the window as full size as per the screen.
• Driver.manage().window().maximize();

3. DELETING Cookies:

Delete cookies in Selenium as per below command

This will not actually delete the physical cookies file from the browser but it bypasses these files that cookies don’t appear in the browsing experience.

4. Closing the Browser:

• close() - Closes the active window
• Driver.close();
• quit() - closes all the windows which are open in Selenium sessions
• Driver.quit();

5. Different Get Methods:

• getCurrentUrl() - This method returns the URL of the currently active page as a string.
• getPageSource() - This method returns the complete HTML source code of the page.
• getTitle() - This method returns the title of the current page as a string.
• getWindowHandle() - This method returns the sessionId or windowHandle as a string.
• getWindowHandles() - This method returns a set of sessionIds or windowHandles.

6. Searching WebElements: 

To search for web elements on a web page below methods are used:

• findElement() - This method returns a web element that matches the REQUIRED criteria.

• findElements() - This method returns a LIST of web elements which match the criteria.

7. Mouse Operations:

Mouse operations like mouse HOVER, drag, and drop, right clickor double click with Selenium actions class is used:

Mouse Hover:      

Actions action = new Actions(Driver);

Drag and Drop:

Tooltip is also known as the Help text. Tooltip is a text that appears when the mouse hovers over an object like a LINK, button image, etc. Sometimes it is a requirement of a project to address tooltip text. This tooltip text provides information RELATED to the object on which it appears. Objects have various attributes in HTML i.e object properties and one of them is “title” which contains tooltip text. SELENIUM’s purpose is to read that text of the object. Tooltip can appear in two ways - Static and Dynamic ways and both can be seen by mouse hover on the object. 

1. Static Tooltip:

Selenium can capture the Static tooltip by calling getAttribute(‘title’) method of WebElement and return the text of title which will be nothing but the tooltip.

We will use the class attribute to make the image object(WebElement) and then we will use the getAttribute method.

2. Dynamic Tooltip:

Dynamic Tooltip in applications is usually created by jQuery/javascript plugins. When we hover mouse on the object, tooltip object appears in HTML and as soon as the mouse is moved the object text DISAPPEARS. The getAttribute(‘title’) will not simply work. In the case of Dynamic tooltip, you have to use the ‘Actions class’ of Selenium.

In the above image, you will see object related to this link but nothing for tooltip

Once you will hover the mouse over the link, you will see a new entry in HTML(div tag ) which is nothing but the tooltip and when you will take the mouse out of the link, below div tag will disappear.

import org.openqa.selenium.By;

Many times test cases fail while running automated test scripts due to various reasons. It might be due to multiple reasons like network ISSUES, system issues or browser issues, etc. and we need to execute test scripts again using TestNG in Selenium. We can test these FAILED cases in two ways:

Case 1: Execute failed test cases using TestNG in Selenium – By using “testng-failed.xml”

1. After the first run of the automated test run, right-click on Project - Click on Refresh
2. A folder will be generated named the “test-output” folder, and inside “test-output” folder, you can find “testng-failed.xml”
3. Run “testng-failed.xml” to execute the failed test cases again.

Case 2: Execute failed test cases using TestNG in Selenium – By Implementing TestNG IRetryAnalyzer.

Create a class to implement IRetryAnalyzer. Here we create a class (say, RetryFailedTestCases) and implementing IRetryAnalyzer.

A simple implementation of this ‘IAnnotationTransformer’ interface can help you set the ‘setRetryAnalyzer’ for ‘ITestAnnotation’. Add the above class name (RetryFailedTestCases.class) in the below program.

We can evaluate the above example by simple tests

Testcase 1:

Testcase 2:

As per the lines of code in Test2, it will fail. So Test2 will be executed 2 times as we took the maxRetryCnt as 2 in Retry Class. First, let us add the below-mentioned Listener to the testng.xml file. The below-mentioned syntax is to add Listener for RetryListnereClass subtext

After executing testng.xml the output shows Test 2 is executed 3 times as we have mentioned “maxRetryCnt=2”. Even though we have just 2 test cases, we could see total test runs are 4 in the result.

This way we could run failed test cases by applying TestNG in Selenium.

Selenium is a set of different software tools each with a different purpose and approach to supporting test automation. Selenium Webdriver is one of the tools in Selenium. The Java version of WebDriver SUPPORTS the IMPLEMENTATION of the Selenium-RC API. WebDriverBackedSelenium is a class name where you can create an object for it. The WebDriver API is fundamentally different in its design COMPARED to Selenium RC. You can use the WebDriver technology using the Selenium-RC API. This is MAINLY provided for backward compatibility. WebDriverBacked selenium allows you to use existing Selenium RC test suites using Selenium-RC API to use WebDriver under the cover. WebDriverBackedSelenium allows you to create tests with Selenium Remote Control syntax.

The main purpose of this is when we want to write code using both WebDriver and selenium RC, we must use the above-created object to use selenium commands.

For Mozilla’s GECKO ENGINE, Marionette is the web automation DRIVER. In the test automation developers community, it is also famous as the Gecko Driver. Marionette can control both the chrome i.e. menus and functions or the content of the webpage loaded inside the browsing context, giving a high level of control and ability to replicate user actions. Along with performing actions on the browser, Marionette can also read the properties and attributes of the DOM

It has two modules, first is the server that accepts requests and executes and the second is a client to forward commands to the server.

We use Marionette to run UI tests in the Firefox browser. A test automation engineer should add its dependencies to the framework, import the required classes and call the methods to control the web PAGE. Marionette also RETURNS the status of commands executed on the browser which can help in verifying the authenticity of the actions performed.

Selenium RC has a complex architecture whereas in WebDriver those complications are removed. Let us discuss why WebDriver is better than the RC.

Selenium RC is slow because it uses an additional JAVASCRIPT LAYER known as the core and On the other hand, WebDriver is fast as it natively SPEAKS with the browser by UTILIZING browser's built-in engine to control it.

The selenium core can not ignore the disabled elements while WebDriver handles the PAGE elements more realistic way.

Selenium RC has a more mature set of APIs but contains redundancies and complicated and confusing commands. Whereas, WebDriver APIs his simpler and have a cleaner interface and do not have redundant and confusing commands.

Selenium RC does not provide support headless HtmlUnit browser. It requires a real visible browser to operate on. On the other hand, WebDriver supports a headless HtmlUnit browser.

Selenium RC includes a test result generator for HTML reports. Whereas WebDriver does not have any built-in reporting ability.

Selenium IDE has a built-in linguistic system called Selenese. Selenese is a collection of Selenium commands to perform actions on a web page.

Selenese can detect broken links on a page, or check the presence of a web element, AJAX, JavaScript alerts and a lot of many things. Mainly there are three types of command in Selenese. 

1. Actions: Action can alter the state of an application. For example,  clicking on a LINK, or selecting a value from the drop-down, etc. Action command DIRECTLY interacts with web elements.
2. Accessors: Accessor commands monitor the state of an application and STORE it into some variable. For example, storeTextPresent, or storeElementPresent, etc are accessor commands because it reads the state of the element and stores it into a variable.
3. Assertions: Assertion commands allow adding a checkpoint or a verification point. The assertion command confirms the CURRENT state of a UI element. These commands verify if a certain condition is met.

When we use ALT/SHIFT/CONTROL keys, we hold onto those keys and click other buttons simultaneously to achieve the SPECIAL functionality.

To  hold onto these keys while SUBSEQUENT keys are pressed, you need to define two more methods: keyDown(modifier_key) and keyUp(modifier_key)

Parameters: Modifier_key (keys.ALT or Keys.SHIFT or Keys.CONTROL)

The purpose is to PERFORM a modifier key press and not to release the modifier key. Subsequent interactions may assume it’s kept pressed.

Parameters: Modifier_key (keys.ALT or Keys.SHIFT or Keys.CONTROL)

The purpose is to Perform a key release.

With a combination of these two methods, you can capture the special function of a particular key.

WebDriver is an Interface which is implemented by FirefoxDriver Class.

FirefoxDriver is a class. It implements all the METHODS of WebDriver interface.

It MAKES the reference of the interface and makes an OBJECT of FirefoxDriver so as to call implemented methods of WebDriver interface.

We declare the left-hand SIDE variable as WebDriver and right-hand side to create an object for a particular type of the browser and ASSIGN it.

Selenese is the set of selenium commands which are used for running the tests

There are three types of Selenese :

• ACTIONS: These are commands used for performing the operations and INTERACTIONS with the target elements and manipulate the STATE of the application
• Assertions: These commands are used as CHECKPOINTS or verification points. It verifies the state of the application conforms to the expected state.
• Accessors: These commands examine the state of the application and store the values in a variables

Desired CAPABILITIES is used to set properties for the WebDriver. It is also used to set the properties of browser such as to set BrowserName, Platform, Version of Browser etc.

Example :

Page Factory in Selenium is an extension to Page OBJECT Model and can be used to initialize web elements that are defined in web page classes or Page Objects.

Page Factory will initialize every WebElement VARIABLE with a reference to a corresponding ELEMENT on the actual web page based on configured “locators”. This is done by using the annotation @FindBy. Example