About File Transfer Protocol

File Transfer Protocol is a widely used standard network protocol for FIle sharing between a client and server in the same network. FTP Server functions with a TCP/IP network. All the client connections are established by switching ON an FTP server.

We are using FileZilla which is a free open source FTP and FTPS server for file sharing.

You can download the FileZilla Client from this link. It is straightforward to configure FileZilla to use a certain FTP server. Let’s see how to test FTP upload and download using Apache JMeter and FileZilla.

(A) Adding FTP Request Sampler

Add Thread Group

Go to Jmeter and add a Thread Group to your Test Plan. Right, Click on Test Plan and Click Add>Threads(Users)>Thread Group.

Add FTP Request Sampler

Add an FTP Request Sampler. Right-click on the created Thread group and click Add>Sampler>FTP Request.

Configure FTP Request

In the opened window, you can use your FTP server username and password. But I am using a publicly available FTP server for this demonstration. You can find the username and password form this link. Find the server called “ftp.swfwmd.state.fl.us” and “anonymous” as username and an email address as the password. Give your server name for the “Server Name or IP” section and fill “Username” and “Password” with your user name and password for the server.

We have to select “get(RETR)”  as we first try to download a file from the server.

(B) Create and Run FTP GET Request

Select Remote File

We have to give the file location address to the “Remote File” section. To get the file location, I used FileZilla. Open FileZilla and fill “Host,” “username,” and “password” with your server address, username, and password provided.

Now you would be able to see the server file locations under the “Remote site” section. I have selected the “README.txt” file in the server to download.

Obtain Remote File URL

Select the file’s address that you want to download by Right click >Copy URL(s) to clipboard.

Update GET Request

Paste it on the Remote File section in JMeter and remove the server address as it has mentioned in the Server name section. Then copy the destination location on your local computer from FileZilla and paste it on the Local File section in JMeter. Give a file name to save your file. I have given the title as ABC.txt.

Add Listeners for Capturing Result

Add a “View Results Tree” listener and “View Results in Table” listener to view your test results.

Run FTP Request and Verify Results

Now click “Start” to run your project and observe the results in listeners. If you have successfully run the components, you can see the results below.

You can also refresh the FileZilla window and check whether the created file appears in the specified directory.

(C) Create and Run FTP POST Request

For running FTP POST via JMeter, you would essentially run the same above steps except changing some parameters and commands in your request which would be different from GET request.

Create FTP Request Sampler

Create an FTP Request Sampler and fill it with the same details as in the previous sampler. Hence you can follow the above steps from 1 To 3 to create FTP Sampler in JMeter and then follow the below steps to configure a POST request instead of GET request.

Alternatively, you can use your existing FTP Post Plan which you prepared using the above steps, and just convert it into a POST test plan by making changes in itself. Both the options are easy peasy!

Update POST Request for Local

I have selected the downloaded file ABC.txt to upload. So the “Local File” location is unchanged. Select a compatible directory in the FTP server to store your data using FileZilla. I have selected a directory in the “/pub/incoming” folder. Verify your results as in the previous section.

Select FTP PUT Command

We have to change the get(RETR) to put(STOR) for posting a file.

Also you can use binary mode over ASCII mode by clicking “Use binary Mode”. You can also view a preview of your file by clicking “Save File in Response?”.

Run FTP Request and Verify Results

Response Data section shows the response data, and it is a better way to check the accuracy of your downloaded file.

We can test the performance of our FTP Servers as in the above instructions. JMeter is one of the best applications for it.

The post How To Create FTP Test Plan in JMeter appeared first on Automation Dojos.

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.

Table of Contents

• Introduction
• System Requirement
  • Step 1: Launch Jmeter.
  • Step 2: Download MySQL Connector
  • Step 3: Unzip and save MySQL Connector
  • Step 4: Now Restart JMeter
  • Step 5 : Create JMeter Thread Group
  • Step 6: Setup Thread Group
  • Step 7 : Add JDBC Config Element for JMeter
  • Step 8: Setup database configuration
  • Step 9: Add JDBC Request Sampler in JMeter
  • Step 10: Prepare SQL query
  • Step 11: Update JDBC connection name
  • Step 12: Add ‘Results in Table’ listner to script
  • Step 13: Add ‘View Results Tree’ Listner
  • Step 14: Run your jmeter script
  • Step 15: View Results Table and Tree

Introduction

In this ‘How-To’, You will be guided to perform a database load test using JMeter. We will be installing Apache JMeter to perform the test. You can download Apache Jmeter from this link as your first step and keep it ready for further steps to follow where we shall be creating, running and analyzing simple demo-based database test script using JMeter.

System Requirement

We would be using the following tools for this exercise:

Step 1: Launch Jmeter.

You can run JMeter using the “ApacheJMeter.jar” file which is in the “bin” folder. Here is a screenshot of JMeter GUI :

Step 2: Download MySQL Connector

We use the Mysql database to create our testing Database. First, you have to connect the MySQL database with JMeter using  MySQL connector. First, navigate to MySQL Website and download the zip folder as shown in the image below :

Step 3: Unzip and save MySQL Connector

Extract the zip folder and Copy “Mysql-connector-java-8.0.20.jar” file (Version may differ) from the folder and paste it into the “lib” folder of JMeter.

Step 4: Now Restart JMeter

Restart the JMeter so that it will work with the library provided by MySQL connector.

Step 5 : Create JMeter Thread Group

Right-click on the Test Plan.Click “Add > Threads(Users) > Thread group” .

Step 6: Setup Thread Group

Give a name to your Thread Group and adjust “Thread Properties” as required.

Step 7 : Add JDBC Config Element for JMeter

Add JDBC Connection Configuration By following the steps : “ Add  > Config Element > JDBC Connection Configuration “

Step 8: Setup database configuration

You have to fill the Database Connection Configurations as below. The Database URL  will be the location of your created database. I have used db4free.net to create the SQL database. Select MySQL driver class for JDBC Driver Class. Enter the username and password of the database in the Username and Password fields. Give the variable name as “testdb” for the created pool field.

The jdbc:mysql://[host1][:port1][,[host2][:port2]]...[/[database]] is the common format for giving your database URL. jdbc:mysql:// “ is an unchanged sequence in JMeter when specifying MySQL database address. The hostname and port name will be emailed after you create the database with db4free.net.

Step 9: Add JDBC Request Sampler in JMeter

To work with data from the database, You need to Add JDBC Request. So add JDBC Request By Clicking  Add > Sampler > JDBC Request as in the image below :

Step 10: Prepare SQL query

You can type and execute the SQL query in the SQL Query section. Select all data from the table by typing the SQL below. Persons is the table name of the database. Select the Query Type as “Select Statement”.

Select * from persons;

Step 11: Update JDBC connection name

Refer the request to JDBC Connection Configuration and give the same variable name in JDBC Connection Configuration variable name field.

Step 12: Add ‘Results in Table’ listner to script

Add “ View Results in Table”  listener. Right-clicking on the database name and click Add > Listener > View Results in Listener.

Step 13: Add ‘View Results Tree’ Listner

Add “View Results Tree” listener. Right-clicking on the database name and click Add > Listener > View Results Tree.

Step 14: Run your jmeter script

Test your database performance by clicking the Run button on the menu bar.

Step 15: View Results Table and Tree

You can observe your results from “View Results in Table” and “View Results Tree” Listeners

If the connection is successful, the sampler result will be given as “OK” for the “Response Message”. Check it out with your connection. You can see that the Latency of my connection is pretty high here. This is the way of checking the performance of a database with JMeter and you can get useful insights to optimize your database connection from it.

The post How To Do Database Testing with JMeter appeared first on Automation Dojos.

Table of Contents

• Introduction
• REST API
• Add HTTP Request Sampler
  • Step 1: Create a Thread Group.
  • Step 2: Create an HTTP Request
  • Step 3: Navigate to ‘OpenWeather’ site
  • Step 4: Get the API call details.
  • Step 5: Fill-in required fields and set ‘Method’.
  • Step 6: Fill-in the API Key parameters.
• Run and Validate
  • Step 7: Add a listner to view response.
  • Step 8: Run your script.
  • Step 9: View the response data.
  • Step 10: Increase load for re-run.
  • Step11: Clear results and Re-Run new load.

Introduction

Application Programming Interface is a very popular term among developers. It is simply a request provider that responds to your request. In other words, it is an intermediate that allows communication between two applications. Google Maps, Twitter, Amazon S3, Weather API are some popular APIs in the industry.

The two widely used Web services are SOAP and API. In this tutorial, you will be learning to use the  REST API with Apache JMeter. Also, you will be able to check their performance with your test parameters.

REST API

Representational State Transfer API is a collection of architectural principles. It has a simple interface that can manipulate and identify the resource easily within the request. We are using Weather API for this tutorial.

Sign up to Weather API in order to get your API key with this link. Your API will be received through email, after the verification of the account. Let’s create a REST API request using JMeter to get the weather data of London, UK with HTTP Request Sampler.

Add HTTP Request Sampler

Step 1: Create a Thread Group.

I have named it as API Testing. Leave the rest of the settings as it is for now.

Step 2: Create an HTTP Request

Create an HTTP Request by following these steps. Right-click on the Thread Group name and click Add > Sampler > HTTP Request.

Step 3: Navigate to ‘OpenWeather’ site

We are using the Current Weather Data API to get current weather data of a certain location. Go to the API page in the Weather API and click “API doc” under the “Current Weather Data” API.

Step 4: Get the API call details.

Get the API call under the “By City Name” Section. Select the first one with the City Name. You can check your city name by searching in the UI search bar of the website. If the name is spelled correctly it will show the weather details as below.

api.openweathermap.org/data/2.5/weather?q={city name}&appid={your api key}

Let’s examine each part of the API call.

“api.openweathermap.org”: IP of the web service.
“/data/2.5/weather”: Path of the web service.
“q”: City Name which you like to get the weather data.London in my case.
“appid”: Your API Key.

Step 5: Fill-in required fields and set ‘Method’.

Complete the required fields in the HTTP Request sampler. Fill the IP and Path with the details above. Select the “Method” as a “Get” Method

Step 6: Fill-in the API Key parameters.

Add City Name and API Key as parameters in the Parameter section. Click the Add button to insert the parameters. Name is the parameter name and value is the parameter value. Check the image below to insert it correctly. I have added “London” to my city.

Run and Validate

Step 7: Add a listner to view response.

You have to add a listener to see the response from the server. Right-click on the thread name and click Add > Listener > View Results Tree to add Results Tree Listener.

Step 8: Run your script.

Run your script by clicking the “Start” button on the menu bar and observe the results in the “View Results Tree Listener”.

Step 9: View the response data.

View received weather data from the “Response Data” section. You can see the weather data in London as requested above.

Step 10: Increase load for re-run.

Increase the load to the API and test the results. Go to Thread Group and Increase the “Number of threads” to 15.

Step11: Clear results and Re-Run new load.

Clear the previous results in the listener by “Clear all” button in the menu bar and re-run the test by “Start” button. You can see the server response to the load that applied. It is responding well. Increase the other thread properties and check the responses as you needed.

Now you can Test an API using Apache JMeter.Use some other web services APIs and test the results. You can check the performance of your API services in that way. Cheers.

The post How To Do API Testing with JMeter 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. Adding Blazemeter Plugin to Browser
• 2. Recording Script via BlazeMeter Plugin
• 3. Importing Script (.jmx file) into JMeter
• 4. Adding JMeter Listeners
• 5. Viewing Result Tree Listener
• 6. Running and Validating Our Script

Honestly speaking if you already have a mature or established process using ‘native’ JMeter from Apache, without any kind of wrappers utilities or third-party tools then this article is of little value to you.

However, there are many companies and/or projects out there who may employ some wrappers or third-party tools, plugins etc. around JMeter, in order to ease out their NFT process while addressing limitations of ‘native’ Apache JMeter. In this regard, there are a number of solutions and plugins available from Blazemeter.

If you don’t want to work natively with JMeter then one such solution from Blazemeter is the Chrome Plugin. The Chrome extension records all of the HTTP/S requests and can create a synced JMeter and Selenium scripts. Furthermore, If you are a registered or licensed user of Blazemeter then it automatically uploads it to BlazeMeter, where you can execute it with a single click.

In this case, there is no need to install JMeter nor Selenium to record or run your performance test, the Chrome extension will create the JMeter and Selenium scripts automatically. The extension will also allow you to debug and test your recorded Selenium session on your local Chrome browser.

However, in this article, we shall be only demonstrating a quick recording scenario using BlazeMeter chrome plugin.We’ll be doing a Login test on a website called demo.taotesting.com.

1. Adding Blazemeter Plugin to Browser

You will need to download and install the BlazeMeter plugin form the Chrome Web store.Simply add the plugin and you are good to go.

2. Recording Script via BlazeMeter Plugin

If you are new to BlazeMeter, you will need to Sign-up. If you are already registered, just Login

Step 1: Name your test.

Step 2: Click the Record button to begin recording the steps of the test.

Step 3: Go to the demo testing site.

Step 4: Enter the Login ID and Password provided therein.

Step 5: Click Log in and ensure that you have successfully logged in.

Step 6: Click “Stop”. BlazeMeter will begin to process your test.

Step 7: Download the .jmx file by clicking the Save Button. In the prompted screen, select “JMeter only” and the domain as taotesting.com. Now click “Save” and the .jmx file will be downloaded.

Now we can start our work with JMeter.

3. Importing Script (.jmx file) into JMeter

Let’s import the test that we just recorded.

Step 1: Click Open in the menu bar and open the downloaded.jmx file into JMeter and save it with your project name.

Step 2. Then you will see the imported components under your Test Plan. Under the Thread Group, you will find the Test scenarios.

The Login ID and Password that was used under the Test will be displayed
>> Test>>https://demo.taotesting.com/tao/Main/login.

4. Adding JMeter Listeners

Listeners are used to display test results in JMeter. They help to monitor the requests sent by JMeter and analyze responses from the server while testing. Time and capacity related information collected for requests and responses from JMeter and statistical information such as distribution and percentages are the main things that listeners deal with.

We have to add a Result Tree listener to view our results.

Right-click on your Test Plan (Testing 2 in my case) >>Add >>Listener >>View Result Tree and you can have the result tree pane.

5. Viewing Result Tree Listener

This listener displays the samplers generated by JMeter and their assertion results. This listener provides request parameters, response parameters, and the response data. It displays the results under the relevant tabs named Sampler Result, Request, and Response Data.

In the Sampler Result, tab you will find information about headers, response code, time-related information such as latency, cookies, error count, etc. The Request tab gives information about HTTP methods, Cookies added, the URL and about the JMeter Script added.

This Listener is able to render the information transmitted into simple formats such as text, HTML or XML. Also, the substrings are filtered by this listener, this helps to construct and validate some post processors. Apart from that, it can display the unsuccessful assertions and compare the actual and expected results. These are some valuable features of View Result Tree Listener.

6. Running and Validating Our Script

Let’s follow these steps to validate our test.

Step 1: Run the test by clicking Start in the menu bar. You will see the verified results in the Result Tree Listener.

Step 2: Check the validated Sampler result, Request, and Response data to see the sample, code verified results, HTML scripts, and Response Headers respectively.

Hint: Change the names of your HTTP Requests to identify them easily. A meaningful name can be provided instead of the HTTP address.

Apache JMeter with BlazeMeter is surely one of the top solutions if you are thinking of venturing with non-native JMeter territory. Even though JMeter has many built-in solutions and features, BlazeMeter is more useful because of the additional features it provides.

Its worth giving a shot, so try it out and see if it works for you. Cheers!

The post How To Record Using BlazeMeter Plugin (JMeter) appeared first on Automation Dojos.