What is a broken link?

Links are used for navigating between webpages. Users are directed to a web page when they click or type a link on a web browser. So a broken link indicates a link that is not working. In other words, it will not navigate the user properly to the requested web page. It happens due to several reasons such as server-side errors, the absence of webpages, typing errors of users.

When a user visits a broken link, they are notified with an error message. While Valid URLs give 2XX status codes, broken URLs give status codes that begin with 400 series, and 500 series .4XX status codes indicate client-side errors, and 5XX status codes indicate server response errors.

Reasons for broken links

Below are some reasons for broken links.

Why Should You Check Broken Links?

Having broken links on your website creates a bad experience for your users. It can seriously affect the reputation of your website. A website usually contains a large number of links. Manually testing each of these links is a time-consuming task. Therefore automating the Selenium Web Driver to check broken links is the best solution for this issue.

Using Selenium WebDriver to find broken links

Testing broken links can be done, as shown in the steps below. The below code is a sample code for a test carried out to https://www.google.co.uk, and relevant facts are discussed below.

package automationproject;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.HttpURLConnection;
import java.util.Iterator;
import java.net.URL;
import java.util.List;
import org.openqa.selenium.*;
import org.openqa.selenium.chrome.ChromeDriver;
public class MyBrokenLinks {

  public static void main(String[] args) {

System.setProperty("webdriver.ie.driver","C:\\Users\\tushar\\eclipse-workspace\\first test\\chromedriver.exe");
    WebDriver mydriver = new ChromeDriver();
    String myhomePage = "https://www.google.co.uk";
    String myurl = "";
    HttpURLConnection myhuc = null;
    int responseCode = 200;
    mydriver = new ChromeDriver();
    mydriver.manage().window().maximize();
    mydriver.get(myhomePage);
    List < WebElement > mylinks = mydriver.findElements(By.tagName("a"));
    Iterator < WebElement > myit = mylinks.iterator();
    while (myit.hasNext()) {

      myurl = myit.next().getAttribute("href");
      System.out.println(myurl);
      if (myurl == null || myurl.isEmpty()) {
        System.out.println("Empty URL or an Unconfigured URL");
        continue;
      }

      if (!myurl.startsWith(myhomePage)) {
        System.out.println("This URL is from another domain");
        continue;
      }

      try {
        myhuc = (HttpURLConnection)(new URL(myurl).openConnection());
        myhuc.setRequestMethod("HEAD");
        myhuc.connect();
        responseCode = myhuc.getResponseCode();
        if (responseCode >= 400) {
          System.out.println(myurl + " This link is broken");
        }
        else {
          System.out.println(myurl + " This link is valid");
        }

      } catch(MalformedURLException ex) {
        ex.printStackTrace();
      } catch(IOException ex) {
        ex.printStackTrace();
      }
    }

    mydriver.quit();
  }
}

Below are my test results.

Each link that is  used in the codes of the web page can be found with the aid of the anchor tag‘<a>.’ The identified links are listed down

List<WebElement> mylinks = drive.findElements(By.tagName("a"));

Then an iterator is placed to move through the created list of links.

Iterator<WebElement> myit = mylinks.iterator();

Identification and Validation of URLs

This step is provided to check the URLs generated with a third party domain or to check it is empty or null. HREF of the anchor tag is stored in a variable called “URL,” and then it is checked as above.

myurl = myit.next().getAttribute("href");

For empty URLs, the below code is used.

if(myurl == null || myurl.isEmpty()){
    System.out.println("Empty URL or an Unconfigured URL");
    continue;
    }
    

The following code is used to determine where the URL belongs to, whether it belongs to the created domain or it is obtained from a third-party provider.

if(!myurl.startsWith(homePage)){
    System.out.println("This URL is from another domain");
    continue;
    }

HTTP Request Sending

Methods in the above, imported “HttpURLConnection” class allows you to send requests and capture responses from the HTTP response codes.

myhuc = (HttpURLConnection)(new URL(myurl).openConnection());

Here “HEAD” is set as request type without using  “GET” to return only headers instead of the body of the document.

myhuc.setRequestMethod("HEAD");

When the connect method is invoked, the actual connection of the URL will be established.

myhuc.connect();

Validating Links

HTTP response should be obtained by the getResponseCode() method.

responseCode = huc.getResponseCode();

Broken links can be determined by the response code number, as mentioned above. Any code that is larger than or equal to 400  can be identified as broken links.

if(responseCode >= 400){
System.out.println(myurl+" This link is broken");
}
else{
System.out.println(myurl+" This link is valid");
}

Testing a broken link is a crucial function to make a good website with an excellent user experience. Users can identify malfunctioning links using Selenium Web Driver testing quickly. This is a tester-friendly version to create a better website.

The post How To Find Broken Links with Selenium appeared first on Automation Dojos.

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.

Table of Contents

• Action & Actions
• A Sample Program
• Conclusion

In this tutorial, we will discuss how to use mouse click events and keyboard events with Selenium WebDriver. The mouse click and keyboard events are used to automate the interactions of a user with a mouse and keyboard.

Action & Actions

We encourage the use of Action and Actions together with the keyboard and mouse events. Action & Actions are user-facing APIs for emulating complex user gestures.

Action is an interface that represents a single user interaction task. Generally,build() method generates a composite action by containing all the actions. On the other hand, Actions implement the builder pattern and it builds a Composite Action that contains all actions specified by method calls.

A Sample Program

Let’s write a simple program explaining these concepts in detail. I’ll select the Facebook website as an example to describe both keyboard and mouse events.

Mouse click event will be triggered when we click the username field. Next, keyboard events will occur when we type the username and password in username and password fields. Again mouseclick event will be used to click on the “Login” button so that we can complete the Facebook login action.

The following image identifies the HTML elements that holds username, password, and log in button.

Accordingly, we can point to all three fields using the ID attribute. Now let’s open the Eclipse IDE and create a new class and name it as Facebook.

Let’s import the libraries.

import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Action;
import org.openqa.selenium.interactions.Actions;

As usual, set the system property to the location of Chrome WebDriver and instantiate a WebDriver element from org.openqa.selenium.

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

Let’s assign the URL for Facebook to the WebDriver element.

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

Next, we will create three new web elements that point to the username, password, and login locations using their IDs.

WebElement username = driver.findElement(By.id("email"));
WebElement password = driver.findElement(By.id("pass"));
WebElement loginButton = driver.findElement(By.id("loginbutton"));

Now, let’s move on to implementing the Action & Actions. We will create a variable called builder from the Actions class. We will use builder to build a composite action that will contain all actions from the method call.

Furthermore, we will create a variable called mouseOver from the Action interface which needs to be used later to run the actions using the build() method.

Actions builder = new Actions(driver);
Action mouseOver = builder
	.moveToElement(username)
	.click()
	.sendKeys(username, "techylosolutions@gmail.com")
	.sendKeys(username, Keys.TAB)
	.sendKeys(password, "This is my Password")
	.build();

According to the code above, the moveToElement method will go to the element where the ID is “email” (username box). Later, it will perform the click mouse event so that you can type the username.

Using the sendKeys keyboard event, we will parse the email as a username. Now let’s move to the password box. You can simply achieve this by pressing the tab key from the username box. We will use the same concept here as well. Using the sendKeys keyboard event, we will press the TAB button so that it moves to the next box.

Finally, we will type the password using the sendKeys keyboard event and compile all the actions with the build() method.

We can use the perform() methods to perform the actions which are mentioned below :

mouseOver.perform(); 

Type username and password into the necessary places then we need to click on the login button in order to complete the task. Once again, we will use the mouse click event for the loginButton variable.

loginButton.click();

This method will simply find the ID ‘login button’. Click on top of it. You will see the next logged-in session on the Facebook site, after giving the correct username and password. Confirm the login By pressing the Login button and we can print the current URL of the page after the successful login.

System.out.println(driver.getCurrentUrl());

That’s all with the demonstration. The entire program is as follows:

package myPackage;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Action;
import org.openqa.selenium.interactions.Actions;
public class Facebook {
public static void main(String[] args) {  	
         		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver_win32\\chromedriver.exe"); 
		WebDriver driver = new ChromeDriver(); 
   		driver.get("https://www.facebook.com/");
         		WebElement username = driver.findElement(By.id("email"));
		WebElement password = driver.findElement(By.id("pass"));
		WebElement loginButton = driver.findElement(By.id("loginbutton"));
         		Actions builder = new Actions(driver);
         		Action mouseOver = builder
			.moveToElement(username)
			.click()
			.sendKeys(username, "This is my Username")
			.sendKeys(username, Keys.TAB)
			.sendKeys(password, "This is my Password")
			.build();
         		mouseOver.perform();  	
         	         	loginButton.click();
         		System.out.println(driver.getCurrentUrl());
   	} 
}

Conclusion

We hope this article helps to understand how mouse and keyboard events work. We hope you apply the same concepts to other webpages and come up with new ideas to automate the keyboard and mouse events with Selenium WebDriver.

The post How To Use Mouse and Keyboard Events with Selenium appeared first on Automation Dojos.

Table of Contents

• 1. What is TestNG?
• 2. Why use TestNG with Selenium?
• 3. Installation of TestNG
• 4. Setting up a TestNG Project
• 5. Creating a TestNG TestFile
• 6. Run Test Case and Generate Report
• 7. Asserts in TestNG
• 8. Summary

1. What is TestNG?

TestNG is an open-source automated testing framework with flexible and powerful features. It is inspired by JUnit and NUnit but with some additional advantages and functionalities. TestNG gives the developers to build tests with easy annotations, sequencing, grouping, and parameterizing.

The ability to generate test reports to get an idea on what test cases passed, failed, and skipped makes it even stronger and a better choice for a test automation framework.

2. Why use TestNG with Selenium?

Selenium does not come with test report generating options. The best thing we can do is printing the results to the console. But with TestNG, we can produce test results in a proper report format through which we can get an overall idea for better analysis. Besides this, there are many other additional advantages TestNG provides.

• Produces test reports in different formats with clear ides of what test passed, failed, and skipped.
• The same test cases can be executed several times by just using a keyword.
• Test cases can be prioritized and grouped and converted to a .xml file.
• Test cases can be run in multiple browsers simultaneously.
• Ability to integrate with tools like Maven and Jenkins.
• Supports parallel testing and load testing.
• Easy and understandable annotations like ‘@’
• It provides the ability to parameterize data.

3. Installation of TestNG

Installing TestNG to Eclipse is pretty easy since it comes as a plugin obtained from Eclipse Marketplace.

• First, Eclipse IDE should be installed on your computer, and it can be downloaded from their website.

• Next, launch Eclipse and go to Help in the menubar and select Eclipse Marketplace.

• Once it is clicked, the Eclipse Marketplace Modal will be displayed. Then you will have to type in “TestNG” and search for it. Once the result comes up, click Install.

4. Setting up a TestNG Project

• Once it is installed, we can create a new Java project by clicking File > New> Project

• Give the name “myTestNGProject” and click Finish

• Next is to import the libraries into the project. Go to project properties > Java Build Path

• Under libraries tab select Add Libraries.

• Then select TestNG and click Next, then Finish.

• Next, add the Selenium jar files into the project the same way as above but select ‘Add External Jars’ under the library tab, and select the .lib files from the folder they are saved at. These library files can be downloaded here.

5. Creating a TestNG TestFile

• Right-click on the “src” file of the project created earlier and select New >Other

• Select the TestNG class under the TestNG folder and click Next.

• Type in the following values in text boxes given and click Finish.

• Once it is done, a default template can be seen in our class created by TestNG

• To create a test case, the following code will be used. The code below will fetch the site https://www.airbnb.com/, verify the title, print out the result, and close the browser.

package myTestNGPackage;

import org.testng.annotations.Test;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;

public class myTestNGFile {
  
  public String baseUrl = "https://www.airbnb.com/";
  String driverPath = "C:\\geckodriver\\geckodriver.exe";
  public WebDriver driver ; 
  @Test
  public void f() {
     
     System.out.println("launching firefox browser"); 
      System.setProperty("webdriver.gecko.driver", driverPath);
      driver = new FirefoxDriver();
      driver.get(baseUrl);
      String expectedTitle = "Vacation Rentals, Homes, Experiences & Places - Airbnb";
      String actualTitle = driver.getTitle();
      Assert.assertEquals(actualTitle, expectedTitle);
      driver.close();
  }
}

6. Run Test Case and Generate Report

Tests can be run the usual way we run a test in Eclipse, but there will be 2 reports. One in the console, which is text-based, and the other in the TestNG result window, which is graphical.

To create HTML reports, right-click on the project, and click Refresh. Then you can see a new folder called “test-output”. Expand it and view the files. There will be a file called index.html. Double click on it to view the report.

The report will open up in the default browser of Eclipse. It is a detailed view of the tests executed, their information, and test results.

7. Asserts in TestNG

Assertions are used to validate test scripts and show whether they have passed or failed. In the above example, we have used Assert.assertEqual(actual value, expected value). If the values do not match the assert with a throw, an exception and the test case will fail.

There are mainly two types of Assertions. One is Hard Assertions, which are default in TestNG and are used to stop a test immediately when an assertion fails. The second one is Soft Assertion, which is a custom assertion that is used when a test has to continue even when an assertion fails in the sequence.

8. Summary

• TestNG is powerful and a flexible testing framework.
• It is inspired by JUnit and NUnit but has better functionalities.
• Using TestNG with Selenium provides many great advantages, including the ability to produce test reports with better visibility of what test cases passed, failed, or skipped.
• To use TestNG in Selenium, we need to create a TestNG class and write the test script on it.
• We use Assertions to verify the status of the test in the middle of the test run.
• Once a test script runs in TestNG, it produces two outputs. One in the console and the other in the TestNG result window.
• After running the test suite, we can obtain the test report in the form of a .html file.

The post How To Use TestNG with Selenium 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

• 1. Selenium and Selenium Web Driver
• 2. Setting-Up the Environment
• 3. Test Script with Selenium Web Driver
  • 3.1) Creating a project
  • 3.2) Creating a Class
• 4. Code a Simple Selenium Script
• 5. Running the test

Testing is a critical step in the Software Development Life Cycle. Software testing helps to ensure the quality and effectiveness of the final product.

Automated Functional testing automates the process of testing and validating each functionality in the software through the execution of pre-defined Automation scripts. This is mainly done for test cases that need to be repeated and are tedious to perform manually.

1. Selenium and Selenium Web Driver?

Selenium is a collection of specialized tools for automating the testing process of web-based applications. This free and open-source tool can be used across different browsers and platforms.

Selenium Web driver is a browser automated framework and accepts written scripts and controls browsers directly. Furthermore, it supports test scripts written in several different languages such as Java, JavaScript, PHP, Python, and C#.

2. Setting-Up the Environment

The following prerequisites must be satisfied to create and run automated test scripts using Selenium.

3. Test Script with Selenium Web Driver

3.1) Creating a project

1. Launch Eclipse from the Start Menu or by double-clicking “eclipse.exe” in the folder “eclipse” where it was installed.
2. To create a new Project, go to File > New and select

3. Now name the project. I’ll be using “FirstWebDriverProject‘.

4. Then click “Finish”. The project will be created and displayed in the Package Explorer.

5. Right-click the project and select New >Package

6. Name the package “newPackage” and click Finish.

3.2) Creating a Class

1. Right-click on the package and select New > Class.

2. Give the name ‘myClass’ and click Finish.

4. Code a Simple Selenium Script

We will now use the new Class to write a script in Selenium Web Driver using Firefox. It will fetch the site https://www.airbnb.com/, verify the title, print out the result and close the browser.

package newPackage;

import org.openqa.selenium.WebDriver;
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.airbnb.com/";
        String expectedTitle = "Vacation Rentals, Homes, Experiences & Places - Airbnb";
        String actualTitle="";
      driver.get(baseUrl);
      actualTitle = driver.getTitle();
      if (actualTitle.contentEquals(expectedTitle)){
         System.out.println("Test Passed!");

         } else {

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

Let’s analyse and understand this code in bit detail:

if (actualTitle.contentEquals(expectedTitle)) {

System.out.println("Test Passed!");

} else {

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

5. Running the test

To run the test script, click Run > Run in the Eclipse menu. Alternatively, you can press Ctrl + F11.

Once everything is done Eclipse will print out the result in its console.

This is just a simple example. There is a lot more that can be done with Selenium. Use this example as the beginning of your Selenium journey!

The post Getting Started with Selenium WebDriver appeared first on Automation Dojos.

Table of Contents

• Testing Challenges in Traditional Setup
• Cloud Testing
• Benefits of Cloud Testing
• Cloud Testing Providers

The ‘Cloud Computing’ technology has revolutionized the IT industry and it has something good to offer to the testing industry too. After Iaas, PaaS, and SaaS concepts, there is a new testing area called Testing as a Service (TaaS) that is making waves in recent times. Increasing IT costs, shrinking budgets and growing business demands pose a great challenge for organizations. Testing as a Service or Cloud Testing answers these challenges by providing cost-effective test solutions built using cutting-edge technologies.

Testing Challenges in Traditional Setup

The first and foremost challenge in today’s organizational setup is the limited budget for the testing team. With changing economic conditions and growing competition, companies have to optimize available resources to the fullest. Allocating separate budgets for testing projects is cumbersome. Moreover, there are strict deadlines that need to be met. Secondly, the testing team creates a large number of test cases that are mostly unused. At times, they are used only once. Thirdly, traditional testing procedures are restricted by geographical locations. Most importantly, there is rapid development in the testing tools segment. World-class testing tools that are engineered with cutting-edge technologies are implemented by large enterprises and small and medium businesses cannot afford to lay a hand on these tools. Cloud Testing offers the luxury of using these cutting-edge technologies at an affordable price. Moreover, TaaS brings greater levels of agility into workflow procedures while improving the performance of the system.

Cloud Testing

Cloud Testing is the new trend in the testing tools segment that uses the cloud environment to simulate real-time traffic. It uses different testing modules to gauge the performance of an application. With cloud-based services dominating the technology, there is a greater need for cloud-based testing.

Benefits of Cloud Testing

Testing as a Service is rapidly gaining momentum in recent times. The primal benefit of a cloud testing environment is the quick deployment of testing tools required for the project. Cloud Testing offers a wide range of testing tools that are built using cutting-edge technologies. Moreover, the testing environment is deployed within a quick time. The performance of the cloud-based testing tool is very good. By bringing agility into testing procedures, cloud testing tools reduce the time taken to identify non-critical defects as well as critical defects.

Most importantly, cloud testing allows businesses to leverage available resources to a maximum extent. You don’t have to invest in various testing modules that are not used most of the time. By paying only for the services used, businesses get the flexibility to optimize budgets and leverage resources. The downside of cloud testing is that it is not suited for some applications. However, the cloud testing environment is rapidly developing to provide a versatile range of services.

Cloud testing is again different from testing a cloud. While cloud testing is about testing an application in the cloud, testing the cloud deals with the evaluation of the cloud infrastructure, applications, and environments that are provided on demand. It is to make sure that the cloud infrastructure is performing according to its cloud computing business objectives.

Cloud Testing Providers

While the cloud testing environment is still new, there are few providers that offer quality testing software. HP Load Runner is one of the leading providers of cloud testing tools. SOASTA, Advaltis, and Cloud Assault are among other contenders for this place.

The ‘Cloud’ innovation is still on the move. Mobile TaaS is another cloud-based testing environment that is used to test mobile applications. With mobile applications created in great volumes, Mobile TaaS has much more to do in the coming days.

The post Introducing Testing-as-a-Service (TaaS) appeared first on Automation Dojos.

Table of Contents

• Test Tool Comparison
• Quick Test Pro (QTP)
• Silk Test
• Selenium
• (1) Features Comparison
• (2) Usability Aspects Comparison
• (3) Comparison of Debugging Features
• (4) Performance Comparison
• (5) System Requirements Comparison
• (6) Technical Support Comparison
• (7) Customer Service & Pricing Comparison
• Conclusion

While manual testing and automated testing go hand in hand, one of the important benefits of automated testing is the assurance that the software is reliable even after updates.

In addition, redundancy detection tests ensure that the integrity of the software is maintained while operational costs are optimized.

The increasing usage of automation tools in recent times has brought in several products into the market, making it tough to choose the right product for your testing needs.

Here is an evaluation of three popular automation test tools.

Test Tool Comparison

Here are the top three automated testing tools that are widely used by testers across the globe. For each of the tools chosen, aspects like the history, striking features, performance, and target audience are considered. In addition, these aspects are considered.

Quick Test Pro (QTP)

Quick Test Pro or QTP is one of the top performers in the automated testing tool arena. With an easy-to-use interface, reliable performance, easy integration with other testing tools and support for .NET environment, QTP has become the leader in the functional and regression testing segment. For a quick history, QTP is a product of Mercury Interactive launched in 2002. In 2007, Hewlett-Packard took over the product to lead the testing tools segment.

QTP is an object-based tool that allows you to automate test operations based on utility, automation or test objects. By being a keyword-driven tool, QTP allows you to use keywords in the creation of test scripts. The tool supports desktop-based and web-based applications and not command-line interface ones. For programming purposes, Microsoft VB scripting is used and data-driven approaches use Excel. Here are some of the striking features of the tool.

Silk Test

For enterprise applications, one of the powerful automated functional and regression testing tool is Silk Test. It was originally designed by Segue Software which was later acquired by Borland and then by Micro Focus International. It supports Object-oriented programming, though partially. You will find objects, classes and inheritance concepts that are seen in C++. It distinguishes each window and control in an application and associated specific attributed to each control for effective object-oriented implementation. The bitmap tool helps the software to capture windows and controls. Using silk test, you can easily identify mouse movements, images on the UI and keystrokes.

Selenium

Selenium is a popular open-source testing tool for web applications. Not only that, but you can also automate administrative tasks as well. The increasing popularity for Selenium is due to the fact that major browser vendors made selenium a native part of their browsers. Whether you want to distribute scripts across multiple environments or create quick bug reproduction scripts, Selenium has the right answer for you.

Selenium is a suite of software testing tools. In 2004, Jason Huggins was testing an internal application when he thought it was a good idea to create a JavaScript library that allows a tester to rerun scripts instead of manually running them on each browser. This is when Selenium got its life. Later, it underwent several updates to turn into a powerful web testing tool.

Here are some of the striking features of Selenium:

Here are some of the factors considered for the evaluation. The first one is the feature set offered by the tool:

(1) Features Comparison

(2) Usability Aspects Comparison

The second important aspect to consider is the usability feature. It is important to check how easy it is to install and run the tool

(3) Comparison of Debugging Features

As automated testing tools allow you to identify errors in the code, debugging is an important aspect that needs proper attention

(4) Performance Comparison

Another important feature to look at is the performance of the tool when running multiple automated scripts.

(5) System Requirements Comparison

Another important aspect to look at is system requirements. Before purchasing an automated testing tool, you should know if it suits your office environment.

(6) Technical Support Comparison

While choosing the right automation testing tool, it is important to check out how the tool supports different aspects

(7) Customer Service & Pricing Comparison

Conclusion

Choosing the right automation testing tool is a tough ask. QTP, Silk Test and Selenium are all popular and powerful automated testing tools. However, choosing the right tool for your testing tasks depends on your infrastructure, testing requirements and expertise coding knowledge.

For large enterprises that can afford to spend dollars, QTP or Silk Test is a good choice. Being a complete suite, it offers a quick and easy way to automate testing tasks. On the other hand, Selenium suits small and medium businesses wherein the tool comes for free. However, testers need to have sound knowledge of coding languages.

The post Automation Tools Comparison (SilkTest vs QTP vs Selenium) appeared first on Automation Dojos.

With rapidly changing financial conditions, businesses face the tough challenge of optimizing resources to produce maximum results. Choosing the right automation tool for functional testing is one of the important tasks in doing so.

The rising popularity and emerging technologies have brought in several testing tools into the market which makes it difficult for organizations to identify the right one for their testing needs.

You have to compare different testing tools and apply the functionality to your business processes to gauge the performance of the tool. Here are certain best practices that need to be followed while evaluating automated testing tools.

1. Feature set

When looking at the tool, one of the important aspects is the feature set. The first benefit of automation is the ease and efficiency it offers for testing purposes. This is what allows you to run automated scripts on multiple codes while you perform other tasks as well.

Object Recognition, Verification and Repository

Another important functionality required by an automated testing tool is the ability to recognize and validate objects while storing them in a repository. As you run multiple scripts, the tool identifies hundreds of objects, standard and custom ones. It should offer an effective mechanism to separately identify each object while associated object attributes as well.

Having a central repository is a desirable option. When you change the name of the object, would you be able to use the object without affecting any part of the application? So, the best thing is to check how the object name mapping system is designed for the tool.

Another desirable feature is image testing. The tool should recognize images and compare one with others. So, check if the tool supports Optical Character Recognition (OCR).

2. Minimum functionality

While having multiple features is always a great idea, it is of no use if the functionality of the tool is not up to the mark. There are certain basic functions that are performed on a regular basis and the automated tool should be able to produce high-quality results. Here are some of the minimum functionalities expected from an automated tool.

3. Usability

The third important aspect to look at is the Usability. Right from installing the product to using various functions, the tool should be easy to use. The installation should be simple and self-explanatory. And, check if coding knowledge is required to run scripts and how long does it take to run scripts. In addition, what does the tool offer for debugging tasks? Does the tool provide adequate documentation and support?

4. Performance

The performance of the automated tool while running multiple scripts is important as well. It is to be robust enough to support enterprise applications. Check how long it takes to create a script and what is the script running time. Moreover, does the tool offer test management tools to effectively track and monitor test progress? And another important consideration is the consistency of test results. The system requirements for the tool need to be considered as well.

 5. Technical Support

While the tool offers extensive features, there should be adequate help and support to resolve technical issues. Check out the support options offered by the tool. While some products offer dedicated support, open-source testing tools generally do not have one. They have large communities and forums wherein you can find resolutions to several issues. However, if you experience any new issue, you will have to create your own resolution or wait for someone to post one.

6. Price

Finally, the price is an important factor as well. Today, some of the leading automated testing tools available in the market are very expensive. At the same time, there are open-source testing tools that are free to download and use. However, it is not a good idea to directly look at the price.

If the tool is expensive, consider the sophistication offered by the tool.

Does it require knowledge and expertise of coding which in turn results in the recruitment of skilled testers? At the same time, if the testing is quick and effective, it improves the development cycle of the product and thereby increases your revenues

While considering the price, the total ROI needs to be calculated that includes the price, licensing, support and maintenance. There are times when staffing, testing time and complexity of testing impact the revenues of the company. So, consider all these factors.

The post Best Practices For Evaluating Automation Tool appeared first on Automation Dojos.