Load testing is a part of integrated performance testing, that checks how fast the system responds to external queries.
The main task of such a type of testing is to check whether a program (device) meets the requirements, defined by a client.
In most cases, this tool is used during the proficient testing of a product, when we need to know how an application will react to its simultaneous usage by several users.
Load testing is mostly used to check multi-user products and various general systems but this doesn’t mean that other types of software resources can’t be tested, with the help of such a method.
For instance, you can test the ability of a photo editor to open an image of huge size.
Moreover, you can find out whether a system is able to give a financial report, by analyzing the information received in the last months or even years. If load testing is qualitatively executed, then the actual results will be absolutely correct.
The main idea of load testing is to create a certain level of load with the help of certain hardware and software tools, in order to study a load index of an application (device).
This method can be the most efficient at the primary stages of development since it will help to receive the most actual results of the product’s performance index.
The principles of load tests
- The time equivalent of the system’s response. If we control a certain number of measurements, we can track when this or that query will occur;
- The uniqueness of queries. While writing a script, we should take the current static data, suggested system behavior, requirements into account;
- Correct reproduction of load profiles. To create qualitative software, we should spend much time and many resources to its design, development and further support. Therefore, there should be a balance between test development and system test coverage. It’s the only way to receive proper results at short notice;
- System distribution depends on a temporary response. The system’s response time depends on a number of hosts since each of them increases the time of delay during scanning of the queries. You should take this into account while writing the requirements for the program’s performance.
Tools for load testing
Some people think the tools used for automated testing can be also used for load testing. So what’s the main difference between them? The difference is that this method works with the help of the tools that work only with system protocols, whereas automated testing is used at the user interface level.
So let’s analyze their differences with the help of such an example: there is a browser that follows a link when a user clicks on a button.
For automated tests, we should create such a script that will send the mouse clicks to the browser. For load testing, we should send a link from the browser to a number of users, that has been established previously, with unique login and password.
We can use numerous free and paid tools for load testing. Let’s analyze the most popular of them.
It’s a very powerful load testing tool, based on Scala. The application consists of two files: the first writes the test scripts and the second – executes them.
Advantages of Gatling:
- Easy debugging of test cases;
- The ability to flexibly interact with various browsers and operating systems;
- Easy bug search at the primary stage of development;
- It shows the reports in a form of graphical tables;
- It interacts well with Jenkins and tests through Gradle and Maven, by using the corresponding plugins.
- It can’t distribute the load between the devices;
- It has no horizontal scaling;
- Making changes into API can lead to difficulties with test case activation of the previously created versions.
After this, we will see the message which will suggest choosing a script.
An example of Gatling in load testing. The bundle is the easiest way to activate testing. You need to move a file into gatling-charts-highcharts-bundle-2.3.0\user-files\simulations\ and launch gatling-charts-highcharts-bundle-2.3.0\bin\gatling.bat.
This tool is one of the most popular free services for load testing, functional testing, and even software development. And since it supports the extensions of other developers, it helps to activate the new functionality.
Advantages of Apache JMeter:
- Displaying the results of the executed work;
- The service is absolutely free for any user;
- There is the possibility to record all actions that happen in a browser;
- IT supports HTTP, SOAP, LDAP, JDBC, JMS, and FTP;
- It can be activated in various browsers since it belongs to Java products;
- You can write your own test cases;
- It integrates with Selenium and Bean Shell for automated test execution;
- It has a user-friendly interface;
- It’s easily launched and installed.
- It doesn’t support the function to record HTTPS connection;
- It has no extended capabilities for writing the reports;
- Is not intercepted by AJAX.
An example of Apache JMeter. Writing Get request to Google.
Before opening the application (click on Run =>Start), you should download the jmx file.
To analyze the usefulness of tests, we should pay our attention to two features: Throughput and Deviation. Throughput is a certain ability of a web server to process complex load.
The quality of the server performance directly depends on throughput: the higher it is, the better is the performance.
It’s also a good application for load testing, based on Java. Scripts are written on a specially developed Jython programming language (the combination of Java and Python). The Grinder is a powerful tool with the possibility to record scripts.
Advantages of the Grinder:
- It’s directly connected with Java;
- It works on all servers where Java can be launched;
- Easy configuration of the features;
- Flexible execution of third-party libraries;
- It supports almost all protocols;
- Development of test cases is fast and easy;
- You may create your own interface plugins.
- The console doesn’t respond to the level of load;
- There may be errors while downloading the huge files;
- You should be familiar with Jython or Clojure, to work with this application;
- There is no possibility to perform extended analysis.
So we have described above the most popular free tools for load testing. There are numerous examples of such reliable programs that are part and parcel for the work of testers and developers. For example, Locust, Apache Bench, Taurus.
If we speak about paid applications, then there are Webload, LoadRunner, Blazemeter and many others. We should choose a tool according to its advantages and disadvantages, we should always take our own skills and competencies into account, and also, we shouldn’t forget about the specific of the peculiarities and complexity of testing and development.