First of all, we’d like to notice that any performance testing is not just a kind of testing but a general description of many testing types that gives data about current system behavior under different circumstances.
Nowadays, software practice includes such performance testing types:
- Load tests;
- Stress testing;
- Endurance (soak) testing;
- Spike tests.
Now, let’s have a look at them separately and in more detail.
Core objective: ensure that a system can withstand the imposed load properly at a particular level. For example, it is necessary to run more than 1000 banking operations that must be processed in 1 second.
A load test is a kind of performance test that gives a clear understanding of how software can behave under a particular load. This test can show a potential margin of your software capacity after which the system stops functioning properly.
Analyzing the load process, one has to take into account the number of users who can simultaneously be in a system and conduct similar operations. Load testing is performed to verify and determine such processes:
- Potential conditions of a high load: provides information for other tests that are created to find software bottlenecks;
- Potential data throughput;
- Response time: is it growing or no;
- Resources usage (external and internal).
Core objective: gradually and continuously increase the load to the software until there is an error or system failure (for example, increasing the number of virtual users until software crashes).
Stress tests are often used to test software that can face an increasing system load. They can inform you about stable software performance when hardware resources are depleted.
For example, a program requires more RAM, disk space, and so on. This kind of testing software performance is used to find and verify web product behavior that must function outside a stable and acceptable load.
This is a little similar to load testing but here the main idea is to push the system beyond its technical limits. A tester has to detect the moment when a web product may fail, how it can happen, and analyze how it can recover (if the software is able to perform the technical recovery procedure).
Stress testing allows knowing a lot of interesting information about:
- Rated limits of a system;
- Failure conditions;
- Degree of the adequacy of the strategy of switching in case of failure.
Also, it is possible to determine:
- Run condition;
- Potential memory leaks.
Endurance (Soak) testing
Core objective: try to imitate classic load within a certain period to ensure that resource utilization remains at the same level (disk space, memory leak, ramp conditions, etc.).
Endurance testing is checking of system performance under regular load over extended periods. Someone may run tests daily while others with proper approach can find bugs in a few hours after the start of a test run. It’s important to understand: even if the load isn’t high, the test may last for a long time.
This approach can allow finding:
- Problems that occur only after long-term use of software;
- Memory leak;
- Time after which a system may crash;
- A number of errors for one unit of time.
Core objective: try to measure software’s ability to deal with the extreme demand curve, handling the high load for a short period, and effectively recover all the resources after this spike.
Such tests are conducted to verify system performance characteristics when it is subjected to high load for a long time. A common pattern is to test the load increases and sharp decreases several times over a long period.
Spike tests help:
- Finding bugs with simultaneous transactions – test run conditions;
- Understanding how quickly the application can scale.
On projects and products where specialists conduct performance testing, spike tests help to find a lot of interesting things. The sudden shock to a system can quickly show bottlenecks and other technical issues that cannot be found with other tests. In most cases, they are caused by initial race conditions.
In the end, we’d like to say that performance testing is an extremely important part of software verification. This testing has its types that are responsible for checking the working efficiency and performance of a system under specified conditions. Performance testing helps to ensure that a system can quickly carry out its tasks.