In this article, I will discuss Headless browsers, why to use them and when not to use them, what is Headless testing and its importance. And lastly an introduction and use of Headless Chrome tool.

Introduction

Headless Browsers are web browsers which don’t have a head or GUI (Graphical User Interface). This means a program runs at the backend to access the web pages but nothing is seen on the screen.

Why use Headless browsers?

• To run tests on headless systems like Linux operating system without GUI.
• To run tests parallelly on multiple browsers on a single machine.
• To utilize minimum resources as GUI is not there.
• Need to run the test just for data creation and not for actual testing.

When not to use these browsers?

• Where there is a need to visually observe the tests on the browser.
• As everything is running on backend and nothing is seen on the screen and UI is not a part of testing so it does not give the exact feedback of what users will actually experience on the website.
• Sometimes errors thrown by Headless browsers are not observed on real browsers.

Introduction to Headless testing and its importance

Headless testing is a method through which browser UI tests can be executed without the head, which implies that there is no browser GUI for running the tests. This is helpful in environments where running the tests does not require the GUI, for eg in a CI environment. With headless browsers, tests execution is fast in a real browser environment so it offers high performance.

What is Headless Chrome?

Headless Chrome is one of the tools which helps in Headless testing on Chrome browser. It can be used in the latest versions (59+) of Google Chrome. It makes it possible to interact with the websites without having a window on the screen.

To work with Headless Chrome, only a terminal and the latest version of Google Chrome is required.

chrome --headless --disable-gpu
 

Let’s see some example of basic operations by Headless Chrome:

1. To create PDF of a page.

chrome --headless --disable-gpu --print-to-pdf

<webpage URL>

The result to this will be a pdf file of webpage titled as output.pdf.

2. To capture a screenshot of a page.

chrome --headless --disable-gpu --screenshot

<webpage URL>

The result to this will be a screenshot of webpage titled as screenshot.png.

To take a screenshot of a custom size, --window-size flag needs to be added to the command.

Hope this article will help you in dealing with Headless browsers and headless testing.

In this article we will discuss about how to configure JMeter to utilize client side certificate to confirm each request. This will make each request signed and encrypted. I believe readers are well aware about the JMeter tool and HTTP request protocol.

INTRODUCTION

HTTPS request is placed by using HTTP protocol, and then covering it with a SSL encryption layer over it. In this case, Servers clients still talk the very same HTTP to one another, however over a protected SSL layer. SSL layer provides encryption and decryption of server and client request & response. Handshaking is used to set up SSL connection between server and client. After the contact is established between server and client, server has to provide its identity to the client through a certificate.

Also, in cases client is required to prove its identity to the server. And these are called client side certificates. Basically, client side certificates are utilized to authenticate the users. To place HTTPS request through JMeter, there is a need to use client side certificates.

JKS (Java Keystore) and PKCS12 are storage for security certificates. These certificates are supported by JMeter. PKCS12 certificates have extension as .p12 and JKS file as .jks. In order to make sure that Java reads all the certificates, they are kept in Java Keystore.

Now we look into the following steps to complete the entire configuration process of JMeter:

1. Making a Java keystore file (eg. keystore.jks)

In order to convert .p12 file into .jks file, following command is used:

keytool -importkeystore -srckeystore certificate.p12 -srcstoretype PKCS12

-srcstorepass <certificate_password> -keystore <keystore_filename>

-storepass <stored_password>

2. Reaching to JMeter directory and opening system.properties file

Here, to match the file values we need to uncomment the following lines:

javax.net.ssl.keyStore=<JKS_filename.jks>

javax.net.ssl.keyStorePassword=JKSpassword

3. Configuring JMeter

To utilize personal keystore to sign HTTPS request though look complex but is a very simple process. Lets understand this further in steps:

Step 1: Create a simple Test plan with a thread group

Step 2: Add HTTP Request sampler for placing request on server

Give careful consideration to the Implementation and Protocol fields .

Step 3: Now add Keystore Configuration element under HTTP Request

cert_name is not a variable name. JMeter here takes only the variable name and for this csv file and JMeter element CSV data set config. is used.

Step 4: Add CSV data set config under thread group and pick value of variable name from csv file :

Place JMeter script file .jmx and csv file at the same location. This solution is very good if we have lot of certificates and lot of variables.

Step 5: In the final step, point JMeter at the keystore we need to utilize.

Click Options --> SSL Manager and select the <keystore_filename> keystore that we made and press Enter.

After doing all the setup, we run the script, enter password set for keystore password and each request now placed JMeter will be signed.

Happy Testing:)

Uploading and Downloading a file in web application is very common functionality. JMeter tool provides the feature of file upload and download and thus makes possible to perform load testing of this feature. This article is about how file upload is performed with JMeter. I believe users are well aware about the JMeter which is a load testing tool.

Introduction:

HTML form based file upload with JMeter is not always easy. But don’t worry this blog will make it simple for you. JMeter provides a means to check file upload as a part of test plan and thus behaviour of the application under load can be checked by increasing the number of Threads/Users in the test plan.

Creating the Test Plan in JMeter for File Upload:

1. Let’s first start with Launching the JMeter and creating the Test Plan :

Right click on Test Plan -> Add -> Threads -> Thread group

2. Add HTTP Request Sampler for placing the request on server :

Right click on Thread Group -> Add -> Sampler -> HTTP Request

3. Add Listener for analysing the response from the server :

Right click on Thread Group -> Add -> Listener -> Summary Report/View Results in Tree/View Results in Table.

Configuring the HTTP Request Sampler for File Upload :

1. Add Server Name or IP and Port Number and path :/

2. File Upload in JMeter is HTTP POST request therefore select Method as POST.

3. A multipart/form-data request needs to be placed on server therefore check multipart/form-data checkbox.

Look at the HTTP Request Sampler:

Next filling details in the Files Upload section of the HTTP Request Sampler :

Click on Files Upload tab and hit the Add button to fill the following data:

• File Path - Path to the file which is to be uploaded (It is good if full file path is provided here).
• Parameter Name - Unique attribute of file type tag.
• MIME Type - Type of the file to be uploaded. For eg in case of text file, MIME Type will be ‘text/plain’, for image it will be image/plain’ etc.

Here, we are considering the example of https://imgbb.com/

So, Let’s start first with placing the image file on JMeter bin folder.

Now to find the parameter name, right click on ‘Start Uploading’ button -> Inspect and identify the unique identifier. Here it is ‘btn btn-big blue’.

So, the values to be passed in the Files Upload section are :

• File Path - test.jpg
• Parameter Name - btn btn-big blue
• MIME Type - image/jpg

After adding these values in the test plan, Save the test plan.

Now before running the Test plan add the numbers of users in the thread group for which load scenario need to be executed and then Run it.

In the next blog, I will discuss about file download with JMeter.

Happy testing:)

Broken Links are a part of a website but it is very important to address them timely and regularly. In today’s article, I am going to discuss what are Broken Links, why they should not be there on a website and how to find these links on a webpage using Selenium Webdriver.

I assume the readers of this article must have good knowledge of Selenium Webdriver automation tool.

What are Broken Links?  

Broken Links are the links or URLs which are not executable because they are linked to an empty or non-existent webpage. Due to a variety of reasons a link can be non-functional or broken such as page is not available, domain is expired etc.

A broken link can be External i.e it is redirecting to a webpage outside of the domain or can be Internal i.e. redirecting to a webpage of the same domain.

What harm Broken Links can cause to a website?

A broken link on a website leaves a bad impression on its viewers and therefore it can hamper websites reputation and business. As the links on web pages affect the rank of a website in search engine results. So, the presence of broken links can highly affect a website’s customer base and its revenue and thus can directly affect business. Looking into these serious consequences, broken links should be regularly detected and immediately handled.

But a link cannot be confirmed as a broken one until it is clicked and response against it is checked. A website can have a large number of links so manually checking each link is a very tedious and time-consuming task. Therefore, here in this article, we will discuss how to complete this task with an automation tool.

Let’s first check the Steps to find Broken Links on a web page:

1. Find all the links on a webpage with tags <a> or <img>.

2. Send HTTP request and get HTTP response from server against each link.

3. Check through the HTTP response (eg 200, 400, 401, 404, 500) whether the link is valid or broken.

Now let’s see the Implementation of these steps :

// Import Packages
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
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;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class BrokenLinksHomepage {
	WebDriver driver;

	@BeforeTest
	public void beforeMethod() throws Exception {
		System.setProperty("webdriver.chrome.driver", "<ChromeDriver Path>");

		driver = new ChromeDriver();

		// Enter url.
		driver.get("http://www.homepage.com/");

		driver.manage().window().maximize();
	}

	@Test
	public void checkBrokenLinks() {
		List<WebElement> allLinks = findAllLinks(driver);

		System.out.println("Total number of elements found " + allLinks.size());

		// Identifying and Validating URL
		for (WebElement element : allLinks) {
			try {
				System.out.println("URL: " + element.getAttribute("href") + " returned " + isLinkBroken(new URL(element.getAttribute("href"))));
			}

			catch (Exception exp) {
				System.out.println("At " + element.getAttribute("innerHTML") + "Exception occured -&gt; " + exp.getMessage());
			}
		}
	}

	public static List<WebElement> findAllLinks(WebDriver driver) {

		// Finding all the links on homepage
		List<WebElement> elementList = new ArrayList<WebElement>();

		elementList = driver.findElements(By.tagName("a"));

		elementList.addAll(driver.findElements(By.tagName("img")));

		List<WebElement> finalList = new ArrayList<WebElement>();

		for (WebElement element : elementList) {
			if (element.getAttribute("href") != null) {
				finalList.add(element);
			}
		}
		return finalList;
	}

	public static int isLinkBroken(URL url) throws Exception {
		// url = new URL("http://homepage.com");

		int response;

		// Send HTTP Request
		HttpURLConnection connection = (HttpURLConnection) url.openConnection();

		// Validating Links
		try {
			connection.connect();

			response = connection.getResponseCode();

			connection.disconnect();

			return response;
		}

		catch (Exception exp) {
			System.out.println("Exception occured" + exp.getMessage());
			return 404;
		}
	}
}

This implementation of finding Broken Links on a webpage is very simple. Try this and eliminate your manual efforts.

Happy Testing:)

In my earlier blog, I have discussed about Data Driven Automation Framework. This is a method in which test data and test script logic are kept separately. Thus a user can easily prepare a test data, modify it and also share it with other person.

Today, in this blog I will discuss about Implementation of Data Driven Automation Framework in Selenium WebDriver. I assume readers of this blog are well aware about Selenium WebDriver automation tool and also what is Data Driven automation framework.

My main focus is to discuss on how to create Test Data in excel sheet, how to import the same data in automation testing tool (Selenium) and further how to feed it to the software under test.

Selenium WebDriver is a popular automation tool used for web-based applications. It uses third party api named Apache POI for performing read and write operations on excel files.

Why Data Driven Testing is required?

Although this I have already discussed in my earlier blog about Data Driven automation framework. In brief, I would say, if you want to execute the same test with different test data than this method is best in itself. It saves both time and effort and improves the efficiency. Also both the positive and negative test cases can be included into a single test.

Tools/Softwares required to Implement Data Driven Testing?

For implementing this testing, following are the prerequisites:

- Java JDK

- TestNG

- Eclipse

- Selenium jars

- Microsoft Office

- Apache POI jars

Apache POI -

Apache POI is the most common JAVA api used for reading and writing test data in excel files. It has many pre-defined methods, classes and interfaces.

Interface in Apache POI -

Apache POI supports both reading and writing data from xls and xlsx files. Following are some of the interfaces of apache POI:

1. XSSFWorkbook: This represents workbook in xlsx file.

2. XSSFSheet: This represents a sheet in XLSX file.

3. XSSFRow: This represents a row in a sheet of XLSX file.

4. XSSFCell: This represents a cell in a row of XLSX file.

5. HSSFWorkbook: This represents workbook in xls file.

6. HSSFSheet: This represents a sheet in XLS file.

7. HSSFRow: This represents a row in a sheet of XLS file.

8. HSSFCell: This represents a cell in a row of XLS file.

Using Selenium with Apache POI -

We’ll now understand how selenium and Apache POI can be used together for reading and writing data into excel files.

Step 1 : Configuring Apache POI in eclipse.

• Download POI jars from the web, unzip them and add them in eclipse project.

Step 2 : Creating Test Data in excel sheets.

• Create an excel sheet named ‘TestData.xlsx’ and save it at the preferred location. You can also save it under project’s package folder.

Step 3: Reading test data from excel sheets.

package <packagename>;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class ReadExcel
{
	WebDriver driver;
	WebDriverWait wait;
	XSSFWorkbook workbook;
	XSSFSheet sheet;
	XSSFCell cell;

 @BeforeTest
 public void TestSetup()
{
	// Set the path of the Firefox driver.
	System.setProperty("webdriver.gecko.driver", "<GeckoDriver Path>");
	driver = new FirefoxDriver();
	
	// Enter url.
	driver.get("http://www.linkedin.com/");
	driver.manage().window().maximize();
	
	wait = new WebDriverWait(driver,30);
	driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
}
 
 @Test
 public void ReadData() throws IOException
 {
	 // Import excel sheet.
	 File src=new File("<TestData.xlsx file path>");
	 
	 // Load the file.
	 FileInputStream finput = new FileInputStream(src);
	 
	 // Load the workbook.
	workbook = new XSSFWorkbook(finput);
	 
     // Load the sheet in which data is stored.
	 sheet= workbook.getSheetAt(0);
	 
	 for(int i=1; i<=sheet.getLastRowNum(); i++)
	 {
		 // Import data for Email.
		 cell = sheet.getRow(i).getCell(1);
		 cell.setCellType(Cell.CELL_TYPE_STRING);
		 driver.findElement(By.id("login-email")).sendKeys(cell.getStringCellValue());
		 
		 // Import data for password.
		 cell = sheet.getRow(i).getCell(2);
		 cell.setCellType(Cell.CELL_TYPE_STRING);
		 driver.findElement(By.id("login-password")).sendKeys(cell.getStringCellValue());
		   		
        }
  } 

}

Through this program line by line test data will be picked after the test execution starts. Check the results in testNG reports.

Step 4 : Executing the test cases

To execute the test cases, right click on the test case class then select Run as - TestNG Test option.

Before the actual execution, please keep in mind the following points:

1. All the required jars are added and properly configured to eclipse project

2. Installation of all the required softwares

3. Interfaces and classes are properly used i.e.HSSF for .xls and XSSF for .xlsx.

4. Usage of valid row and column index.

5. Excel file is not opened before execution.

By using Data Driven framework in Selenium using POI, helps in reduction of maintenance cost and effort, also test coverage is improved which results in good return on investment.

I hope this blog will save you from the tedious task of executing the same test cases again & again.

I believe you would have heard about the JMeter listeners and maybe probably used some of them. Today, in this article I am going to discuss JMeter Graph Results listener.

JMeter, as you are aware of, is a performance testing tool and after doing testing, monitoring and analysis of different test results and parameters is the most important part. Thus, here come the listeners in the picture, they provide UI to view the sent request and response received from the server. These results can also be saved in files for later use or can be viewed live while the tests are running.

What is Graph Results listener?

Graph Results listener allow us to view the test results in the form of a graph. It generates a simple graph in which all sample time is plotted against the response time. This helps us in analyzing the result in less time and with more understanding.

Now first let’s see how we can add this listener to our Test Plan:

Step 1: Create a Test Plan

Right Click Test Plan > Threads (Users)

Set values of No. of Threads (users) as 1000, Ramp Up Period (in seconds) as 1 and Loop Count as 1.

Step 2: Add HTTP Request sampler

Right Click on Thread Group > Add > Sampler > HTTP request

Give a Name to the sampler > Set Server Name, Port, HTTP Request Method, and Path (if required).

Step 3: All Graph Results Listener

Right Click on Thread Group > Add > Listener > Graph Results.

Step 4: Save this Test Plan and Run the test.

Now check the result on Graph Results listener. The result will be somewhat similar to as shown below:

Here, the data in the bottom of the graph displays the current values in milliseconds. Black shows the current sample, Blue shows the current Average of all the samples, Red shows current Standard deviation i.e. deviation of the response time. It should be as low as possible. And Green shows current Throughput rate.

The Throughput rate is the total number of requests handled by server per minute. This time includes total JMeter’s processing time and also if any delay is added to the test. So, we can say that the test produces some real data.

The value on the top left of the graph is maximum of 90

the percentile of response time i.e. it shows the elapsed time below wich 90% of samples fall.

We can save the graph result by specifying Filepath in Filename field under “Write results to file/Read from file”.

I hope this blog will prove useful to you.

Happy Testing:)

In my last article, I discussed “structured scripting framework” which uses structured programming instructions like the control structures for controlling a different flow of the test cases or test scripts.

In this article, I will discuss third automation framework i.e. “Data Driven Automation Framework”. I will explain in brief about this framework, how it is useful and Merits and Demerits in using it.

Data Driven Automation Framework

As the name says, in this framework, automation test scripts are driven by data i.e. data files are used to fetch input and output test values. The test data can be stored in any of the external databases like text files, xml files, excel sheets, csv files, property files. While testing an application it is required to test a functionality multiple times with multiple test data so, in that case, each test data cannot be put in test scripts as this will be time consuming and inefficient. Therefore, data is stored in external database thus segregating test data and test script logic.

Test Scripting can also be done using Linear scripting framework.

It is very convenient and useful to keep test data in external storages as a user can easily prepare it, modify it and also share it with another person. For eg have a look at the below table in which data is stored in an excel sheet.

 

Each row holds a test data for one test script and can be checked or assigned. However, multiple rows can also be used.

 

Now let’s have a look at the operations in a data-driven test

1. Fetching input data from the storage file.

2. Entering the same data into application script.

3. Writing back the output in the file.

4. Verifying the actual result with the expected Result.

5. Picking next set of input test data.    

 

In my coming blogs, we will see how to perform these steps with an example.

 

Every framework has some advantages and disadvantages associated with them. Let’s see them for this framework:

Merits:

1. Test script size is reduced.

2. Change in test data does not affect test script logic.

3. Code maintainability and flexibility increases.

4. Multiple test scenarios can be executed with a particular test script.

5. Supports better error handling as the function returns TRUE or FALSE values instead of aborting the script.

 

Demerits:

1. Proficiency is required in writing the scripts.

2. Data files need to be maintained for each test case.

3. Data files need to be handled properly in order to avoid script processing errors.

 

 

In my next blog, I will discuss the implementation of Data Driven Automation Framework with Selenium Webdriver.

Hope you are enjoying reading about different automation frameworks.

Happy Reading:)

 

Today I have a very interesting topic to discuss and that is Performing API Testing using Rest-Assured Framework.

Before proceeding with this topic I assume the readers have good knowledge of TestNG Framework.  In this blog, I will discuss briefly Rest-Assured Framework, Set up of Rest-Assured Jars in Eclipse Project and make a GET request using Rest-Assured.

What is Rest-Assured

Rest-Assured is a JAVA library which can be used for writing tests for RESTful APIs. It also has assertions for validating the API responses and forms a good combination with TestNG libraries.

Steps to setup Rest-Assured Jars

1. Download and Setup Java, Eclipse and TestNG.

2. Download Rest-Assured Jars.

3. Create a Project in eclipse.

4. In the classpath of eclipse set Rest-Assured Jars.

After the initial setup is done, let’s now understand how to make GET request with Rest-Assured

Consider the following example:

EndPoint - https://example.com/api/countries/<country>

HTTP method Type - GET

Response -

{
     "countryId": 1,

     "name": "India,

     "capital": "Delhi”,
     "states": 29,

     "territories": 7,

     "phoneCode": "91"
   },

Comment - Above response is fetched for the country India.

To fetch this response from Rest-Assured, following steps are to be executed:

1. Using Rest-Assured class, RequestSpecification is generated for the URL: https://example.com/api/countries/India

2. HTTP method is specified.

3. Request is send to server.

4. Response is received from server.

5. Response body is printed.

import org.testng.annotations.Test;
import io.restassured.RestAssured;
import io.restassured.response.Response;
import io.restassured.specification.RequestSpecification;


public class Example {
	
	@Test
	public void listCountries()
	{
               
                // Using Rest-Assured class to setup a request
                RestAssured.baseURI = "https://example.com/api/countries";
		// Getting the RequestSpecification of the request
		RequestSpecification httpRequest = RestAssured.given();
		

                // Making GET request directly by RequestSpecification.get() method
		Response response = httpRequest.get(“/India");
		

                //Retrieving Body of response
		String body = response.getBody().asString();
		//Retrieving Status Code of response
		int status = response.getStatusCode();
		//Retrieving Status Line
		String statusLine = response.getStatusLine();
		

		//Printing the response
		System.out.println("Response Body is "+body);
		System.out.println("Status code is "+status);
		System.out.println("Status line is "+statusLine);
         }

}

Note:

RequestSpecification is an interface and in a Rest-Assured library, all requests are represented by this interface.

Above code is written considering positive test scenario but similar can be used for testing negative scenarios also. Try it by yourself and share.

In my next article, I will share about making a POST request using Rest-Assured.

Enjoy Automation Testing :)

In my previous blog, I have discussed about “Linear scripting automation framework”, in which through the record and playback technique, testing step is captured and is written in a script file.

In this article, I am going to discuss the next automation framework which is “Structured Scripting technique” . We will discuss what is this framework, how it is different from Linear scripting , its uses and pros and cons in using it.

 

Structured Scripting framework

Structured scripting uses structured programming instructions like the control structures. These are used for controlling different flow of the test cases or test scripts. ‘If-else’, ‘while’, ‘for’ and ‘switch’ are examples of control structures. These help in performing some steps in the scripts iteratively and in basic decision-making, that in certain conditions how the test will respond and whether it will pass or fail.

 

This framework has the capacity of declaring numerous lines of code into one set of tasks which helps in code reusability and easy maintenance. The fact that the user has to define a function at only one place and can reuse it anywhere in the test script. Also it provides an ease in addressing the issue at only one place where it is defined. As with increase in functionality, scripts becomes more complex so code reusability becomes a more important part.

 

Unlike Linear scripting framework, for implementing Structured scripting, only testing skills are not sufficient one has to develop his programming skills also. As linear scripting may give a large script with numerous lines and repetitive functions, so it needs good scripting knowledge to convert that code into few meaningful lines.

 

Merits associated with it:

1. Supports code reusability unlike linear scripting.

2. Due to code reuse, cost of developing scripts is less.

3. Less maintenance of the script is required.

 

Demerits associated with it:

1. Technical skills are required in writing the scripts.

2. Test planning and preparation requires comparatively more time.

3. Hard coded test data is used.

 

 

In my next article, I will discuss about Data Driven Automation framework.

 

Keep Reading:)

In this blog, I will discuss TestNG assertions and how to use them with Selenium scripts. I believe readers have some basic knowledge about Selenium tool and TestNG framework.

What is Assertion?

The assertion is a checkpoint which can be used in between the test scripts in order to verify the test status against a test condition. In a simple manner, Asserts give us a way to test the expected result with the actual result. Asserts are most frequently used methods while creating Selenium WebDriver test scripts.

Let’s understand how an assert is used:

Test Case - We need to verify Page Title of an application named “Ezbitex’.

If actual result matches with the expected one then the test passes otherwise it is marked as failed. We can understand this with the code below:

@Test
	public void verifyPageTitle() {
		driver= new FirefoxDriver();
		driver.navigate().to("http://ezbitex.com");
		Assert.assertEqual("Ezbitex", driver.getTitle());
	}

In the first line, we are saying that any object passed to the driver (reference variable) will be an instance of FirefoxDriver class. In the next line, we are navigating to the application URL. And the third line is an Assertion. In this line, we are checking the page title. As it is matched, so the test gets passed.

Now, If the same assertion statement is written as below:

Assert.assertEqual("Ezzzzzzbitex", driver.getTitle());

@Test
	public void verifyGooglePage() {
		driver= new FirefoxDriver();
		driver.navigate().to("http://google.com");
		Assert.assertEquals("Gooogle", driver.getTitle(), "Strings are not matching");
		// a code to login and using a method ‘isUserLoggedInSuccessfully’ and ‘isUserLoggedOut’ which returns boolean.
		Assert.assertTrue(isUserLoggedInSuccessfully(), "User failed to login");
		Assert.assertFalse(isUserLoggedOut());
		}
}

In this article, I will discuss Test Automation framework, its types and then one of the basic framework type.

This article is written keeping in mind that you are aware of the term “automation” in software testing.

Understanding the term Test Automation Framework:

Test Automation reduces manual efforts by automating repetitive tasks, thus it brings increased efficiency, effectivity and coverage in software testing. In order to simplify and scale testing efforts, frameworks are used. A framework can be defined as a template with some set of guidelines which can be used to run automation test scripts in required order to produce efficient results. However, I want to make it clear that framework is totally different from an automation tool which performs a specific task. Rather it is an infrastructure which provides the solution for tools to perform tasks in a consistent manner.

Thus, in brief, Test Automation Framework is a suit of components which facilitates creation & execution of automated test scripts and supports reporting of the related results.

Types of Test Automation Frameworks:

5 primary test automation frameworks are:

1. Linear Scripting

2. Structured Scripting

3. Data-Driven

4. Keyword-Driven

5. Hybrid

About Linear Scripting Automation Framework:

It is the simplest of all frameworks as it uses Record and Playback mechanism to capture each testing step and write it out in a script file. Each interaction is recorded in separate line with checkpoints and validations. Using this framework is a very good way to start with basic automation testing as it forms a base in understanding all other advanced frameworks. It is mainly used to automate small sized applications and is suitable where requirements do not change frequently.

Testers can work directly on recorded scripts and can make changes according to their test scenarios and test cases. For example :

a. Loops can be written where steps are repetitive.

b. Validations can be added to ensure full proof testing.

Merits of using it:

• It provides the fastest way to generate automation test script.

• Extensive knowledge of programming language not required.

• Features of automation testing tool can be learned easily with it.

Demerits associated with it:

• Maintenance of scripts is required.

• Reusability of code is very less.

• Test data is hardcoded thus running tests with multiple data sets is not possible.

In my next blog, I will discuss on other automation frameworks.

Keep reading!!

What is an Order?

It is an instruction given electronically to broker/exchange that you are interested to buy/sell underlying at a specific price. A single order can be a sell order or a buy ordr, which can be used either to enter or to exit a trade. If a buy order is used to enter a trade, then only a sell order will be used to exit it.

So now we can understand what is Trade?

In simple terms when orders are completed or executed it is called Trade i.e. when a buy order matches a sell order or vice versa. For example Joe wants to buy a good at Rs 50 and Bob wants to sell the same good at Rs 50. So, this buy and sell order gets matched and is said that trade has been done.

Let’s see what are the main order types and how they can be used:

Limit Order

When you know upfront at what price you want to buy/sell underlying, it is Limit Order. It has 2 components.

a) Limit Price -

It is the price at which you want to buy/sell underlying.

b) Transaction Type (Buy/Sell) -

It is what type of transaction you want to perform.

How it works

For example, if Joe place a buy limit order of Rs 100.05 (this becomes the limit price), the order only gets executed at Rs 100.05 or better (in this case a good price is below Rs 100.05).

Now if Bob is willing to sell at Rs 100.05 then the order gets complete and will be executed.

Thus, Limit order is carried out at a price of your choice.

Market Order

When you are very desperate to buy/sell something, you can use market order. Market order is placed at market price. It has 1 component.

a) Transaction Type -

It is what type of transaction you want to perform.

How it works

For example, Joe placed a market order when the price was Rs 100 but this can be the case that other orders gets executed first at this price and Joe’s order gets completed at Rs 102 only.

So, this says that market orders always carry a risk with them of executing at a slight different price.

Stop Order

When you are not sure about the movement of market and want to protect your existing position, you can use Stop order. It has 3 components.

a) Trigger Price -

It is the price beyond which you want to keep a limit.

b) Price -

It is the price at which you want to exit your current position after trigger price is hit.

c) Transaction Type -

It is what type of transaction you want to perform.

How it works

For example, Market price is Rs 200, Joe wants to trade above Rs 202 (trigger price), so he keeps the price at Rs 204 so as market hits at Rs 204 or beyond his order will be executed. The same if wants to trade below Rs 198 (trigger price), so he keeps the price as Rs 196 so as market hits at Rs 196 or below his order will be executed.

Thus, this clearly shows that when a buy order is placed, stop price should be kept beyond the current price and when a sell order is placed, stop price should be kept below the current price.

I hope this blog will be useful in understanding the trading orders.

You must have heard about the Joint bank accounts in which two or more persons are owners of the same account and thus account activity is visible to all of them and is carried out only with the consensus of all. Similarly, Multisignature or Multisig technology have the same feature. In this, multiple private keys are required to sign a transaction. Basically, this technology is designed to add additional security to the transaction of cryptocurrencies.

Standard cryptocurrency transactions require only a single key for the verification of the transaction. It looks like a single private key provides complete autonomy to the owner of funds. However, this is risky as this system gives complete power in a single string of alphanumeric numbers. And unfortunately, if this key is lost then all the funds of the owner is also lost. But this situation can be avoided by using MultiSignature addresses or wallets.

Multisignature wallets require more than a single key and can require a particular combination of keys to verify the transaction and release the funds. In this wallet, it can be defined that total of how many signatures are there for a transaction and out of which how many are required to make a transaction. Therefore, they are also called as M-of-N transactions, where M defines the required number of signatures or keys and N defines the total number of signatures or keys involved in the transaction. The most common multi-sig wallet is a 2-of-3 wallet, means out of three total signatures, two are required for signing a transaction.

With this technology, it becomes really impossible to hack and stole the funds and thus it imparts high safety and security to the owner’s funds.

Now let’s understand this with an example:

Bob, CEO, and owner of a company run bitcoin business. He has a concern of keeping his funds save and he knew that this could not be possible with a single-signature wallet as with single key, it was a concern that with whom funds and this key are safe and it is not accidentally lost. Also if the key is replicated then there is a risk of keys hacked and stolen. So in order to prevent this, he used 2-of-3 multi-sig wallet. Let’s see how this wallet helped him,

Sign 1: CEO (without backup)

Sign 2: Accountant (without backup)

Sign 3: In a paper wallet in safe held by board team

The setup is planned in this way that neither the CEO nor the accountant can take away the company money as no one is the single holder of the key. And to access the funds 2 of 3 signatures are always required. Accountant after preparing and signing can pass the payments to the CEO, who then by adding his sign can give further confirmation of the fund release. If either of the two disappears or loses their device, then they can still get access to the company funds with the paper wallet held by the board. So funds are secure and cannot be hacked.

The Simple Test plan of JMeter is that one user is hitting only one API/request. But in the real scenario, multiple users will always be there who will hit either single api or multiple apis. This can be understood by a simple example that a live application will be used by many users simultaneously and also multiple requests can be send by the same user on that application. Thus checking the application with this test scenario is very important. In JMeter we can create multiple users and multiple requests and also the combination of both of them.

Let's understand this with examples:

Test Scenario 1: Single User hitting multiple (3) http apis.

Step 1: Create a simple Test Plan with 1 Thread group and add three simple controllers under it i.e With text template, With html template and Without template. Right click Thread Group > Add > Logic Controller > Simple Controller

Step 2: Add http request sampler under each controller and fill the required fields. Right click controller > Add > Sampler > HTTP Request

Step 3: To view the results add a Listener 'View Results in Table' and check the result. Right click Thread Group > Add > Listener > View Results in Table

Now check the result. It shows a single user hits 3 different http apis successfully.

Test Scenario 2: Multiple users (5) hitting multiple (5) http apis.

Step 1: Create a Test Plan with 5 Thread groups. In each of the Thread groups keep the same configuration as Number of Threads -1 ; Ramp Up period - 1 and Loop Count - 1

Step 2 : Now under each thread group add http request sampler and fill the fields. Right click Thread Group > Add > Sampler > HTTP Request

Step 3 : To view the results add a Listener 'View Results in Table' and check the result. Right click Test Plan > Add > Listener > View Results in Table

Now check the result. It shows 5 users hits 5 different http apis successfully.

Thanks!!

In simple test plan, requests send by JMeter to the application is continuous i.e. one after the other. But in the real scenario, there is always a time interval (milliseconds) between the requests. Thus to check the application with a particular number of requests per minute we can use the JMeter element named 'Constant Throughput Timer'.
During testing, it is required that a load of particular throughput need to be sent to the application. In that case, this timer can be used to achieve the result.
Implementing this timer in test plan is very simple and easy. It can be added under controller with the path --> Right click on Controller > Add > Select Timer > Constant Throughput Timer.

Now let's see a sample JMeter test plan which uses Constant Throughput Timer to execute 10 requests per minute:

Step 1
Following configurations done in Threads groups:
Number of threads - 1, Ramp up period - 1 and Loop Count - Forever

Step 2
Constant Throughput Timer addedwiththroughtput = 10 and Calculate Throughput based on = all active threads. This implies per minute 10 requests will be executed.

Step 3
Now check the time difference between the 1st sample and 11th sample, it is 1 minute. This shows the desired result of hitting 10 samples per minute is successfully achieved.

Thanks

Happy Testing!!

Trello is an open source web based project management application which organises the project information in the boards. The most important requirement for using these type of tools in our projects is to manage and to save or backup the data efficiently. Organizing data in Trello is very easy and user friendly. And for the backup of data, currently free version of Trello allow to export data into a JSON format. Export feature is available under the Board Menu > More > Print and Export.

Board Menu at the right most corner:

Print and Export option:

In the above pic, we have seen that only Export JSON option is available but if excel support is required then currently Trello does not has this feature in free version, only after subscribing with Business Class package on paid basis, this feature will be included. But not to worry as we can also get this feature simply by downloading a Chrome extension which alows to export data from Trello board to Excel xlsx file without paying a penny. Isn't interesting..that without paying anything Trello Business class feature can be used. Here is how we can do so:

Step 1:
Open Chrome Web store and search for extension named Export for Trello.

Step 2:
Click on Add to Chrome option.

Step 3:
Once the installation is complete, check for icon on chrome browser at the rightmost corner.

Step 4:
Next step is to refresh the Trello page once or twice and go to the path Board Menu > More > Print and Export. 'Export Excel' option will start appearing.

Step 5:
Click on the Export Excel link and check the downloaded file. All the cards present in the board will be shown as column names on excel sheet. And each column contains data of the corresponding board.

I hope this feature will help you a lot and will definitely eliminate most of your manual task. So start using this feature today only and enjoy Trello.

Thanks!!

A shell is a software in a Linux or Unix operating system which provides a text-only user interface to enter commands (i.e. instructions). These commands are then executed and the output is displayed on a screen. In addition to this, a shell can also run commands stored in a file. And this mode of execution is known as shell scripting.

There are thousands of Linux commands and it is really difficult to remember them all. So here comes the need for automation. Shell scripts are short programs which are extremely useful for automating tasks on Linux or Unix operating systems. It is a simple text file containing a sequence of commands to be executed in one go by the operating system which otherwise has to be entered from the keyboard one at a time.

The shells used on Linux systems contains a built-in programming language i.e. shell programming language or shell scripting language and is used to create shell scripts. 

Out of many advantages of shell scripts we have already seen one i.e., it automates frequently executed tasks. Others are as follows:
1) They are very easy to develop.
2) Used to combine multiple sequences of commands into a single command.
3) As it is a text file, it can be easily viewed and thus diagnosing problems with it is easy and fast.
4) They can be transferred and executed on other Linux or Unix operating systems.

Let's see below some of the Use of shell scripts:
1) Application startup scripts.
2) Automating the setup process of application.
3) Gathering system/component information after a specified task.
4) Deleting desired files after a specified tasks eg server log files.

Now we'll understand this with the simple task of 'How to grep load and CPU utilization of a machine for half an hour with a regular interval of 5 minutes'.

Step 1: Create a file named load.sh

Step 2: Write the following commands into it:
#! /bin/bash
tdate=`date '+%D %H:%M:%S'`
load=`cat /proc/loadavg | awk '{print $1}' `
totalcpu=`top -b n2 | grep 'Cpu(s)' | cut -d',' -f1 | cut -d':' -f2 | tail -1`

echo -e "$tdate $load $totalcpu
sleep 300
done

Explanation of the above script:

date '+%D %H:%M:%S - this will give server date, hour, minute and second.

/proc/loadavg -
/proc is a virtual filesystem which is sometimes referred as process information pseudo filesystem. 
/proc/loadavg is the system's 'load average'; 3 indicators which depict the amount of work system did during last 1, 5 and 15 minutes.

awk '{print $1}' -
The basic command for awk is:
awk 'pattern {action}' input file > output file 
$1 refers to first column

top -b n2 command -
This will execute the top command twice (n2 = 2 iterations), 'b' is used for the bash script.

grep 'Cpu(s)'-
This will grep the line containing 'Cpu(s)'.

cut -d',' -f1 and cut -d':' -f2
This will print selected parts of the line. 'd' is for a delimiter. 'f' is the flag for selecting the field.

tail -1
This will display the last line of the file.

echo
This will show the output.

sleep 300
This delays execution of the script for 5 minutes (i.e 300 sec).

Step 3: run the script with the following command and write the result into a CSV file named Result.csv
sh load.sh >> Result.csv

Step 4: Check the readings in Result.CSV file

Thanks

Happy Scripting.

Apache Jmeter is an open source performance testing tool. It is used to carry out load and performance tests for many different servers. It has a simple and user friendly GUI through which new elements, thread groups and samplers can be added and result can be viewed through different listeners.

However, there are some limitations with JMeter in GUI mode, like
a) After a certain limit (of threads/users), JMeter crashes.
b) CPU utilization slows down.
c) Usage of multiple listeners affects its performance. 

So to avoid these issues and to drive more requests per second, JMeter scripts can be run in non GUI mode. Once the script is done and verified in GUI mode, it is better to move to non GUI mode for execution. 

Running JMeter in non GUI mode is very easy. Let's understand how we can do that:

1.Just remember the below syntax:
<JMeter path> jmeter -n -t <script location> -l <logfile location>

-n --> specifies Jmeter in non GUI mode
-t --> specifies JMX file that has the test plan
-l --> specifies JTL file that logs test results
-j --> specifies Jmeter log file name.

2. Check the test results:
After the test is complete, JTL file will be generated inside apache jmeter bin folder.
The file can be viewed in 2 ways either by opening the file on the terminal itself or in JMeter GUI mode.

Let's understand it here with an example:
Step 1:
Reach to JMeter bin folder.

Step 2:
Save JMeter script in the folder.

Step 3:
Run the syntax on terminal
./jmeter.sh -n -t TestScript.jmx -l test11.jtl  &

Step 4:
Once the JMeter test is complete, the following will be displayed in nohup.out file which is created inside bin folder:

Let's see the stats and understand what they tell us:
87570 in 00:00:30 = 2919.0/s - means in 30 seconds 87570 requests send to server with an average throughput of 2919 requests per second.
Avg: 24 - means average response time at that time is 24 milliseconds.
Min: 1 - minimum response time for that period is 1.
Max: 3395 - maximum response time for tht period is 3395.
Err: 0(0.00%) - means no errorin requests for tht period and % of error from total request is zero.
Active: 219 - no. of active users performing requests.
Started:2770 - no. of started threads from the begining of test.
Finished:2551 - total no. of threads finished fro m the beginning of test.

Hope this blog will help you out.

Thanks

Happy Testing.

Is it possible that software which is 99% Bug free, but is still unusable?

Answer to this question is YES, it is possible. This happens when software is tested thoroughly but for wrong requirements. Therefore this should be always kept in mind that just because at the time of testing, defects were not found in the software, doesn’t mean that the software is ready to be shipped. Before making a decision to ship the software, a question needs to be asked. Were the executed test cases really designed to search most of the defects? or were they designed to check whether the software matched the user’s requirements?
If the software which is developed is not used as it does not fulfill user’s requirements and expectations then finding and fixing the defects will not help.

Coming to Absence of error fallacy, let us understand this with the help of an example. 
Imagine, our company developed a school management software. Complete testing of the software is done and about 99% of the defects which were identified have been fixed and also retesting on them is done. This report has been submitted to management and this has given them pretty much confidence about the product quality w.r.t. defects.
Now when the demonstration of software is given to the client, he gives his feedback saying “Though it is called defect free, but still this is not what I required.AS I wanted a simple UI which can handle the user load.”

Now before receiving this feedback, everyone in the Testing team was very much confident and sure about the 'quality' of product (i.e. absence of errors) but in the end, it proved to be false (i.e. fallacy). This straightaway means that the system is not usable by the client as it does not fulfill his expectations.

Therefore, it is very much important to note that the Client's requirements and expectations are as important as the quality of product.

Happy Testing:)

“If you plug it in, and smoke comes out..”

Well, this line pretty much sums up what a Smoke testing intends to do. Like in Hardware testing, as the first test is done to check that hardware do not catch fire (or smoked) in the initial switch on, in the same way, Smoke testing is done before starting actual testing to check all critical functionalities of the application are working fine.

Smoke Testing, when performed on a particular build, is also known as “Build Verification Testing”. This testing covers almost all the main functionalities of the software but none of them in depth. The result of this testing decides whether a build is stable enough to proceed with further testing or not. Means if the smoke test cases pass, further testing can be done but if it fails, further testing need to stop immediately and a new build with the required fixes is asked.

This testing is normally used at Integration Testing, System Testing and Acceptance Testing levels. It can be performed manually or with the help of automation tools/scripts on both newly created software and enhanced software. Smoke testing should not be considered a substitute for functional/regression testing.

When to do Smoke testing?

Smoke testing is performed in the following scenarios:
1. Performed by developers before giving build to the testing team.
2. Performed by testers before starting the detailed testing.
3. Performed to ensure that the basic functionalities of the application are working fine.

What to do in Smoke Testing?

While performing Smoke Testing we need to ask the following simple questions:
1. “Can user able to access software application?”
2. “Does user able to navigates from one window to other?”
3. “Does application GUI is responsive?”
 and etc etc...

Definitely, the above list of questions will increase according to the functionality of the application. But please remember, Smoke testing is not performed with negative scenarios and with invalid data.

Why do Smoke Testing?

The answer to this simple and important question is:
1. Bugs are found in the early stage of testing.
2. Issues that got introduced by the integration of components are found.
3. Issues fixed in the previous build can be verified and this will give the certainty that they are NOT impacting the major functionalities of the application.
4. A limited number of test cases are required to do the testing.
5. Testing can be carried out in a small time.

Why is ONLY Smoke Testing not enough?

Smoke Testing is followed by exhaustive testing because:
1. Detailed testing is not covered by smoke testing.
2. Other critical issues are not found as it's a non-exhaustive testing with a small number of test cases.

Now it's your turn to try out this Testing...

Happy Testing:)

Have you heard of the term 'Portability Testing'...
So, before going into this topic lets first understand what is meant by the word 'Portable'.  Anything which can be 'easily carried or moved' is called portable. Thus Portability in high-level computer programming is defined as usability of the same software in different environments.

If we want to move our software component or application from one hardware, software or other operational or usage environment to another, then 'Portability Testing' should be high on our list of testing requirements.
This testing validates that an application can be installed on multiple operating systems, can be used on multiple devices, is compatible with other leading independent software, or it can replace a previous version of the same or similar software.

Following are some of the examples for which Portability Testing is necessary:

a. Designing a software to run on Windows operating system, Linux, and Mac OS X.

b. Developing an application to run on Google Android, Apple iOS, and Windows OS.

c. Developing an application that is compatible on web browsers viz. Internet Explorer X, Mozilla Firefox, and Google Chrome.

While conducting Portability Testing following attributes/parameters are to be necessarily considered:

1. Installability : In this we ensure that can an application be installed to the desired environment without using any extra resources.

2. Adaptability : In this we ensure that can a software adapt to a particular environment without putting any extra effort.

3. Replaceability : In this we ensure that can a software application replace other software in a particular environment.

4. Co-existence : In this we ensure that can a software application work with other software application on the system, without disturbing each other and sharing the same resource.

After understanding that how much is this testing important, now let's see what are the benefits of performing it:

1. All end users will have the same experience.

2. Application will work as intended in all applicable configurations.

3. It will save money by finding issues before production.

So don't leave your application to go live without executing this testing...

Happy Testing:)

Ever wondered where the term ‘bug’ came from in Software world?
The month you see under the tape (See the picture below) is the reason why the word "bug" came in use to describe computer problems.

The U.S. Navy Rear Admiral Grace Hopper, coined the terms bug and debug after an incident happened in Harvard University involving Mark II Aiken Relay Calculator (a primitive computer).

Here the story begins...
On September 9, 1947, while testing Mark II Relay calculator, a moth was found trapped between the points of Relay # 70 in Panel F. In those days, computers filled large rooms and the warmth of internal components attracted flies, moths, and other flying creatures. These creatures then shorten the circuits and thus cause the computers to malfunction. That day the same thing happened but what was different from other days was that the operator removed the moth from the machine and affixed it to the log book (See the picture below), with the entry “First actual case of bug being found”. And that's the first time when anyone used the word 'bug' to describe a computer glitch. After this incident the word went out that they had "debugged" the machine and in this way the term "debugging a computer program" was born. Eventually the terms became so popular, that we are still using them today.

We can say, without that moth, we may have a different term for errors in a computer system.

So, next time when your computer or smartphone crashes and you suspect a bug, then think back to this image:)

Regards