1. Desired Capabilities in Selenium

The performance of a Web application may vary according to different browsers and operating systems. Hence to ship out a near-consistent functional and performant application, it calls for testing your applications against different browsers or browser configurations. That is where Selenium’s ‘Desired Capabilities’ class comes into the picture.

‘DesiredCapabilities’ is a class in Selenium that can be used to define and set some generic capabilities or settings for browsers. The ‘Desired Capabilities’ applies to WebDriver and is used to modify the properties of the web driver.

This class resides in the org.openqa.selenium.remote.DesiredCapabilities package. We use these desired capabilities as key or value pairs to set them for browsers. In this tutorial, we will discuss the ‘Desired Capabilities’ feature in Selenium in detail.

2. What about ChromeOptions Class

Chrome Options class provides methods for setting ChromeDriver-specific capabilities and hence can be used for manipulating various properties of the ChromeDriver. Similar to Chrome there are browser options classes available for Firefox, Safari, Edge and Internet Explorer, etc as well.

Given below is a simple example of ChromeOptions usage to give you an idea. The example below shows how to open the chrome browser in Maximize mode.

ChromeOptions chromeOptions = new ChromeOptions()
chromeOptions.addArgument("start-maximized");
ChromeDriver driver = new ChromeDriver(chromeOptions);

As you can see in the above example the scope of ‘ChromeOptions’ applies to Chrome or Chrome Driver while the ‘Desired Capability’ applies to WebDriver. This will get more clear with the below examples.

3. When and Where to Use

Generally, the ChromeOptions class and all such browser-specific classes (FirefoxOptions, Safari, Internet Explorer) are used in conjunction with ‘Desired Capabilities’ for customizing the behavior of your Selenium WebDriver.

So you can set your browser-specific options using browser-specific classes such as ChromeOptions, FireFoxOptions, SafariOptions, etc. You can then pass on these objects to the DesiredCapabilities class object. So now your desired capability knows what you want for different types of browsers.

To further spice-up things you can use your prepared and customized ‘DesiredCapabilities’ object in Selenium Grid targeting different machines or browsers. This may give you what we call a multi-browser test environment where the same test case needs to be executed on different browsers.

4. Available Capabilities for Browser Types

Chrome offers a long list of options to control the browser settings. You can find this whole list of switches here. Besides here are some most commonly used arguments for ChromeOptions class :

4.1) ChromeOptions for Chrome

4.2) Firefox, Safari, Edge and IE Options

Similarly, you can checkout browser options for other browsers like Safari, IE, Edge, Firefox, etc. on the following links:

4.3) DesiredCapability Class Options

The Selenium WebDriver’s DesiredCapability class as well offers a long list of capabilities and options. Some of the most used common ones are:

Also, you can see the whole list of DesiredCapabilities options on this page on GitHub

5. Desired Capabilities Methods and Types

Let’s look at the methods available with ‘Desired Capabilities’ class. As mentioned ‘org.openqa.selenium.remote.DesiredCapabilities’ is the package that has the class named DesiredCapabilities as a component. Selenium web drivers can change and set up properties for web browsers from their methods. Let’s discuss some commonly used methods in the DesiredCapabilities package.

6. Usage Scenarios for DesiredCapabilities

Now, that you know the methods in DesiredCapabilities class, let’s see some of their common uses. First, let’s do an example using just the ‘DesiredCapabilities’ class.

6.1) DesiredCapabilities Example

The below example shows how Desired Capabilities enables chrome browsers to accept SSL certificates on websites. With Desired Capabilities, it is just three lines of code. You just have to use the “CapabilityType.ACCEPT_SSL_CERTS” with setCapabilities method. See the code below.

(a) Accept SSL Certs

DesiredCapabilities capabilities = DesiredCapabilities.chrome();
capabilities.setCapability(CapabilityType.ACCEPT_SSL_CERTS, true);
WebDriver driver = new ChromeDriver(capabilities);

6.2) DesiredCapabilities with ChromeOptions

ChromeOptions class is used to control the properties of the Chrome browser. The example below shows how to open the chrome browser in Maximize mode.

ChromeOptions chromeOptions = new ChromeOptions()
chromeOptions.addArgument("start-maximized");
ChromeDriver driver = new ChromeDriver(chromeOptions);

(a) Start Chrome Maximized

Now we can create a ‘Desire Capabilities’ class object and pass the ‘options’ we had set for our chrome object (which in this case is the (‘start maximized). Once the ‘Desired Capability’ object has received the options set for ‘chrome browser’ in this case, then we can further create our ‘Web Driver’ object using this ‘capability model’ as parameter.

ChromeOptions chromeOptions = new ChromeOptions()
chromeOptions.addArgument("start-maximized");
DesiredCapabilities capabilities = DesiredCapabilities.chrome();
capabilities.setCapability(ChromeOptions.CAPABILITY, chromeOptions);
WebDriver driver=new ChromeDriver(capabilities);

(b) Disable Chrome Extensions

The following code disables extensions of Chrome which is particularly useful when you want to disable developer mode while testing.

ChromeOptions chromeOptions = new ChromeOptions()
chromeOptions.addArgument("--disable-extensions");
DesiredCapabilities capabilities = DesiredCapabilities.chrome();
capabilities.setCapability(ChromeOptions.CAPABILITY, chromeOptions);
WebDriver driver=new ChromeDriver(capabilities);

(c) Start Chrome Incognito Mode

Likewise, If you want to open the incognito window, use “–incognito” argument in the addArdument() method.

ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.addArguments("--incognito");
DesiredCapabilities capabilities = DesiredCapabilities.chrome();
capabilities.setCapability(ChromeOptions.CAPABILITY, chromeOptions);
WebDriver driver=new ChromeDriver(capabilities);

(d) Enable Adblocker in Chrome

Finally, let’s go for a more complicated one. You definitely need to enable an adblocker while testing through a browser. Enabling the adblocker has few steps. You have to download and extract the CRX file related to the Adblocker extension from here. Then you have to pass the path of the extracted file in the code. The following code will do the task.

ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.addExtensions(new File("Path to CRX File"));
DesiredCapabilities caps = new DesiredCapabilities();
capabilities.setCapability(ChromeOptions.CAPABILITY, chromeOptions);
ChromeDriver chromeDriver = new ChromeDriver(caps);

6.3) DesiredCapabilities with FirefoxOptions

Using Desired Capabilities with Firefox and IE is quite similar to how we do it with Chrome. So let’s do just one example from each of them. The following code lets you open Firefox in headless mode.

(a) Start Firefox in Headless Mode

DesiredCapabilities desiredCapabilities = DesiredCapabilities.firefox();
FirefoxOptions firefoxOptions = new FirefoxOptions();
firefoxOptions.setHeadless(headless);
desiredCapabilities.merge(firefoxOptions);

6.4) DesiredCapabilities with InternetExplorer

(a) Enable IE for SSL and Check Focus

Similarly, You can check that if the Internet Explorer has the focus before you do start any interactions with it. The below code also force IE to accept SSL certificates.

DesiredCapabilities desiredCapabilities = DesiredCapabilities.internetExplorer();
desiredCapabilities.setCapability("requireWindowFocus", true);
desiredCapabilities.setCapability(CapabilityType.ACCEPT_SSL_CERTS, true);

Conclusion

Desired Capabilities are the beginning of advanced testing. It’s something really important to know if you are going to do anything more than basic testing. They provide so much functionality with so little code. Using them is pretty simple and quite similar across different uses. I hope you enjoyed our tutorial. Let’s meet again with another exciting tutorial.

The post Desired Capabilities in Selenium Web Driver appeared first on Automation Dojos.

I’m going to explain in this tutorial about the usage of the findElement and findElements method of Selenium Webdriver on the Chrome web browser. The findElement method is used when you want to deal with one HTML element on a website. On the other hand, the findElements method is used when you want to deal with more than one HTML element.

In brief, the findElement method returns a single element, and the findElements method returns an array of elements.

We will choose a dynamic website – “BBC News”, to explain this concept in a real scenario. We will use the findElement method to display the headlines of the webpage and we will use findElements methods to display the menu items.

First, let’s have a look at the web page to analyze the HTML code and select the necessary attributes.

We can see that the news headline text appears within the block-link__overlay-link class. 

The menu items are within anchor tags, which displays as a list inside a div tag. To acquire the menu item text, we need to reference an attribute that points towards all of them. However, the anchor tags are inside the list tags which we can’t address in common.

The div tag has a unique ID that we can use to capture the div. After capturing the div, We will be accessing the UL tag. However, We need to have some techniques to access the <a> tag inside the <ul> list(Example is shown below).

A Sample Program

Now let’s program to demonstrate the above concept using Java language. First, open the Eclipse IDE and create a new class and name it as BBCNews.

Next, we will import the necessary libraries.

import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

Next, we will instantiate the Chrome WebDriver. For this purpose, we need to set the system property which points to the location of Chrome WebDriver. Then we have to instantiate a WebDriver element (from org.openqa.selenium.WebDriver library) to the Chrome web browser

System.setProperty("webdriver.chrome.driver", "D:\\Chromedriver\\chromedriver.exe"); 
WebDriver driver=new ChromeDriver();

After that, we will assign the URL of the BBC News website to the Chrome WebDriver.

driver.get("https://www.bbc.com/");

Now let’s see how to grab the headline on the webpage using the findElement method. First, we will create a WebElement (from org.openqa.selenium.WebElement library) to store the headline element.

The findElement and findElements methods can return the elements in the following ways:

Obtaining the element using className would be ideal, as the class attribute is available within the anchor tag that holds the headline.

WebElement element = driver.findElement(By.className("block-link__overlay-link"));

Finally, let’s see how to get the menu items using findElements method. We will create a list of WebElements to store all the menu items. You can use the cssSelector or xpath. But, we will use a special technique to combine both findElement & findElements methods.

We will locate the div tag using the findElement method and then, we will grab all the anchor tags which hold the menu items using the findElements method.

List<WebElement> elements = driver.findElement(By.id("orb-nav-links")).findElements(By.tagName("a"));

We can finally print all the elements using a ‘for loop’. When printing the elements we will use the getAttribute(“innerHTML”) so that it prints the text inside the HTML tag!

You can see the entire program as below :

package myPackage;
import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver; 
public class BBCNews {
public static void main(String[] args) { 
    	System.setProperty("webdriver.chrome.driver", "D:\\chromedriver_win32\\chromedriver.exe"); 
   	WebDriver driver=new ChromeDriver(); 
   	driver.get("https://www.bbc.com/");
   	WebElement element = driver.findElement(By.className("block-link__overlay-link"));
	System.out.println("Headline: " + element.getText());
   	List<WebElement> elements = driver.findElement(By.id("orb-nav-links")).findElements(By.tagName("a"));	
	for (int i=0; i<elements.size();i++){
		System.out.println(elements.get(i).getAttribute("innerHTML"));
	}    	     
	}
}

Conclusion

We hope this article helps to understand how both findElement & findElements methods work in different ways. We hope you apply the same concepts to other webpages and come up with new ideas to automate with Selenium WebDriver.

The post Finding Web Elements with Selenium appeared first on Automation Dojos.

Table of Contents

• 1. Selenium WebElements
• 2. WebElement Locators
• 3. Working With Text Box
• 4. Working With Buttons
• 5. Checkboxes and Radio Buttons
• 6. Selecting from Drop-Downs
• 7. File Uploads
• 8. Locating Links
• 9. Summary

In our previous tutorial, Getting Started with Selenium WebDriver, we discussed the way to set up the environment for automating testing using Selenium and wrote a basic script to do a simple test. In this tutorial, we will discuss other functionalities of the Selenium Web Driver in depth with examples.

1. Selenium WebElements

Web Element is a class in Web Driver to handle different  HTML elements of a web page. It can locate and perform different functionalities upon them. Following are the two methods, commonly used to obtain AUT elements directly and to store them as WebElement objects.

In order to create objects of WebElement, we need to import the package Selenium.WebElement

2. WebElement Locators

Locating different web elements are extremely crucial in testing web pages since the chance of ending up with incorrect elements is higher. Therefore, Selenium WebElement has introduced several different ”Locators” to locate web elements using their unique properties precisely. They can be easily identified using the Selenium IDE or Browser’s Developer Tool. Below is a list of Locators and their syntaxes.

Once the elements are located, different functionalities can be performed on them. In this tutorial, we will be using a sample web form to explain how Selenium WebElements can be used to test its various form elements.

3. Working With Text Box

Initially, we need to create WebElements for the ‘Firstname’ and ‘Lastname’ fields.

Once the element objects are made, the first thing to do is to clear the text, which is already in the text field. This is done by the clear() method.

Finally, we can enter the relevant text using the sendKeys() method by sending the text value as the parameter.

4. Working With Buttons

Buttons are usually accessed through the click() method. In the case of Submit buttons, the submit() method will be used to submit all the inputs to the server.

In this case, the className is used as the locator to find the button.

5. Checkboxes and Radio Buttons

Toggling checkboxes on or off and selecting radio buttons are done using the click() method.

The checkbox element is located using its XPath. This code checks if the checkbox is selected or not and then prints a message.

In the case of Radio Buttons, it is located using cssSelector.

6. Selecting from Drop-Downs

Before selecting values from a drop-down, we need to import a package.

Once that is done, we can declare the drop-down as a Select object.

Now we can control the drop-down by selecting its values using different methods defined in the Select class.

We can repeat the above code with different parameters when selecting multiple items.

7. File Uploads

There are a couple of solutions available for implementing ‘File Upload’ functionality within your selenium scripts. However, not all solutions may work on all applications because at times it may depend on typical ‘design or kind of implementation’ your application or website uses at the backend and/or client end.

However here is one such, simple implementation for File uploading. In the below snippet ‘File Uploading’ is simply done by locating the file-select input field and by entering the path of the file to be uploaded using the sendKeys() method.

8. Locating Links

We can locate links and access them using the linkText() and partialLinkText() locators. In the below example, we will obtain the link with its complete text using linkText() and part of the link text using partialLinkText() locator.

Here is the complete code.

package newPackage;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.Select;
import org.openqa.selenium.firefox.FirefoxDriver;

public class myClass {

   public static void main(String[]args) throws InterruptedException{
      System.setProperty("webdriver.gecko.driver", "C:\\geckodriver\\geckodriver.exe");
      
      WebDriver driver = new FirefoxDriver();
      
      String baseUrl = "https://www.toolsqa.com/automation-practice-form/";
        String pageTitle="";
      driver.get(baseUrl);
      
      //Clicking a link text using linkText Locator
      driver.findElement(By.linkText("Partial Link Test")).click();
      System.out.println(driver.getTitle());
      Thread.sleep(1000);
      
      //Clicking a link text using partialLinkText Locator
      driver.findElement(By.partialLinkText("Partial")).click();
      System.out.println(driver.getTitle());
      
      //Capturing the page title
      pageTitle = driver.getTitle();
      
      //Get webElements for First name and Last name text boxes
      //Locator by name
      WebElement firstName= driver.findElement(By.name("firstname"));
      //Locator by Id
      WebElement lastName= driver.findElement(By.id("lastname"));
      
      //Clearing the text fields
      firstName.clear();
      lastName.clear();
      
      //Entering values to the text field
      firstName.sendKeys("John");
      lastName.sendKeys("Doe");
      
      //Get webElements for gender radio buttons using cssSelector
      WebElement radioMale=driver.findElement(By.cssSelector("input#sex-0"));
      //Selecting it using click()method and printing their values.
      radioMale.click();
      System.out.println("Male Selected");
      
      WebElement radioFmale=driver.findElement(By.cssSelector("input#sex-1"));
      radioFmale.click();
      System.out.println("Female Selected");
      
      //Selecting years of experience radio button
      WebElement yrsExp= driver.findElement(By.id("exp-2"));
      yrsExp.click();
      //Printing the number of experience selected
      System.out.println("Years of Experience = " + yrsExp.getText());
      
      //Entering values in Date text box
      WebElement date= driver.findElement(By.id("datepicker"));
      date.sendKeys("17-12-2019");
      
      //Selecting Profession Check box
      WebElement prof= driver.findElement(By.id("profession-0"));
      prof.click();
      
      //uploading a file
      WebElement uploadElement = driver.findElement(By.id("photo"));
      uploadElement.sendKeys("C:\\profilePic.jpg");
      
      //Creating web element for selecting Automation tool using xpath
      WebElement selQtp= driver.findElement(By.xpath("//*[@id=\'tool-0']"));
      // Toggling on and off to see if selected
      selQtp.click();	
      
      if (selQtp.isSelected())
         System.out.println("QTP Selected");
      else
         System.out.println("QTP Not Selected");
      //Unchecking
      selQtp.click();	
      
      if (!selQtp.isSelected())
         System.out.println("QTP Not Selected");
      
      //Selecting single continent using drop down
      Select singleContiDrp = new Select(driver.findElement(By.id("continents")));
      
      singleContiDrp.deselectByVisibleText("South America");
      
      //Selecting multiple continent using drop down
      Select contiDrp = new Select(driver.findElement(By.id("continentsmultiple")));
      
      contiDrp.deselectByVisibleText("Asia");
      contiDrp.deselectByVisibleText("Europe");
      
      //Locating button using className
      WebElement firstBtn= driver.findElement(By.className("btn btn-info"));
      firstBtn.click();
   
      
      Thread.sleep(1000);
      if (pageTitle.contentEquals(driver.getTitle())){
         System.out.println("Test Passed!");

         } else {

         System.out.println("Test Failed");}	 
      driver.close();
      
   }
   
}

9. Summary

The post Working with Selenium WebElements appeared first on Automation Dojos.

Table of Contents

• Virtual User Generator (VuGen)
• Controller and Load Generator
• Result Analysis
• Common issues with Load Runner

HP Load Runner is a popular automated load and performance testing tool that emulates actual load to check the performance and behavior of a product. Load Runner comprises three important components namely Virtual User Generator (VuGen), Controller and Load Generator and Analysis.

In fact, before we start discussing the ‘common issues’, let’s take a moment to go through the main LoadRunner components in brief as this would make the terms used in this article more meaningful and clear.

Virtual User Generator (VuGen)

For load and performance testing, you need to create scripts for simulating transactions. That is what VUGen does, in fact, it is one of the most important and most frequently used components of LoadRunner. As a scripting tool, VuGen enables you to create specific user scripts that record various transactions. In addition to creating user scripts, VuGen allows the following tasks:

Controller and Load Generator

The controller is responsible for executing scripts. When VuGen creates user scripts to simulate transactions, the next requirement is the creation of user case scenarios that simulate the behaviour of a user. These user cases or Vusers are executed and managed by the controller from a single workstation. In addition to passing scripts to the Load Generator which executes Vuser scripts, the controller collects the resulting information for analysis.

Result Analysis

HP Load Runner offers analytic tools that enable you to create detailed reports from Vuser logs generated after the execution of tests. You can either analyze reports from a single test or compare multiple tests.

Common issues with Load Runner

While HP Load Runner is a great tool to increase the quality of a product, technical issues can be frustrating as well. Here are some of the common issues experienced while working with Load Runner.

The post Common Issues with HP Load Runner appeared first on Automation Dojos.

WATIR stands for ‘Web Testing Application in Ruby‘. It is an OLE-based testing application that automates your browser using Ruby libraries. Here are some of the pros and cons of Watir in brief at first glance.

Functionality of Watir

Watir takes advantage of the built-in OLE capabilities of Ruby to automate browsers. Normally, HTTP-based tools create a browser simulator for a web-based testing system. Watir works in a different way wherein it takes the browser through the OLE protocol. By implementing the OLE protocol over Component Object Model (COM) architecture, Watir facilitates inter-process communication between the browser and Ruby. Dynamic object creation and manipulation is made possible as well.

For Internet Explorer, this process is called OLE Automation. The program that manipulates objects is called the automation controller. The automation objects are served by the Internet Explorer which is why it is called as the server. On the other hand, the Ruby program acts as a client to manipulate objects.

The post A Brief Review Of WATIR appeared first on Automation Dojos.