Whether you’re developing an API to power other applications or building an API within your own corporate infrastructure, you need to establish a reliable testing process to prevent performance problems and understand any vulnerabilities or weaknesses in your API. This way, you can prepare for failure scenarios.
Being caught unaware when performance problems occur with your APIs can be costly and — if you aren’t prepared with the right processes in place — time consuming to fix. The damage done to your application’s reputation in the event of an unforeseen failure can be irreversible.
Hopefully, you’re already using functional tests to ensure that your APIs perform as intended and that they meet your business needs from day one. This is a critical first step, but how can you ensure that your API will perform as expected in a real world situation?
And how can you ensure that your SOAP and REST services can stand up to heavy traffic in high demand situations? This is where load testing comes in.
API load testing is about creating production level load simulations within an application or system that is as close as possible to a finished product that is ready to deploy, or an existing application that’s already being used by customers.
By utilizing specialized testing software, load testing allows testers to answer questions like “Is my system doing what I expect under these conditions?”, “How will my application respond when a failure occurs?”, and “Is my application’s performance good enough?”
“A load test enables you to measure response times, throughput rates, and resource utilization levels, and to identify your application’s breaking point, assuming that the breaking point occurs below the peak load condition.” - Microsoft guide Performance Testing Guidance for Web Applications
API load testing tools allow you to manage important factors within the load test like test length, failure conditions, and how virtual load will impact your API to create the most realistic possible scenario. You can generate load either via rate, to simulate machine-to-machine behavior or virtual user, to simulate actual users interacting with your API models, change the wait time between executions, and specify which test cases you want to load test.
Fortunately, with the right tools, it is not necessary for load testing to add a significant amount of bandwidth to your API testing workload.
Load testing can be automated just like functional testing, so that you can run your load tests late at night to avoid potential customer impact and testing resources.
You’ll be able to use these tests to:
- Test the speed and scalability of new changes to your APIs in minutes
- Preview API performance behaviors before releasing to production environments
- Shift performance insights more to the left so developers build more reliable code
- Stress test your API to see where and when performance degradation occurs
Let’s say that you’re developing a mobile banking application and you’ve set up a functional test to ensure a user’s full name gets pulled in from your database through an internal API.
You have performed functional tests on your API and as a result, you know that the typical response time is 200 milliseconds and now you want to see how that API will perform under a high volume of traffic.
With API virtualization, minimal resources are required for standing up and testing the API. You are able to test the API itself, not the end-to-end application with all its required backend systems. This eliminates the need for a clone of the production environment. That means you don’t have to reset and reload downstream data anymore.
You have a sandbox environment that can be used to stress test your API through a variety of different scenarios and you can measure and compare those results to get data about the performance of your API that might otherwise be difficult or cumbersome to obtain.
As you get started with load testing your API for performance-related problems, there are a few areas you’ll want to focus on:
1. Start with the new code first
New code can introduce a certain amount of chaos into your systems when you put it into production. Don’t let new code slip through untested. Catch errors, bugs, performance problems, and get ahead of the game by establishing specific requirements in your business cycle to test new code before it’s put into production.
To ensure the quality of your tests, it’s important to provide specific requirements for how many business users, or how many transactions, to use in your load test. Part of that requirement will also need to include volume over a period of time. For example, if you have a statement that says “When I click this button, I’m going to send a thousand emails,” you need to be specific and also provide a timeframe around it.
That way, when conducting the test, you’ll be getting a more reliable view of how your API will perform in a real world situation.
Establish specific requirements and make sure the entire team is incorporating them into their continuous delivery cycle, or, if you haven’t achieved continuous delivery yet, make it a part of your pre-release testing plan.
2. Test for problems on the back end
When you’re looking at overall performance, it’s important to understand what will happen on the front end when back end problems arise.
If you have the right tools, this type of full view testing is simple. With a tool like LoadUI NG Pro, you can set up tests that replicate what will happen when a third party or dependent API is unavailable, slow, generating errors, or another malfunction occurs.
Maybe you’re highly reliant on another third party API that’s a small business. You need to know what would happen if their API doesn’t meet their SLA, or Service Level Agreement.
You need to be able to simulate that possibility in your load testing approach to see what happens to the rest of the transactional process from a performance perspective, when an event like that occurs.
That knowledge will enable you to better understand how your API will perform when the API calls it depends on aren’t available or are responding too slowly. From there, you can optimize your API to handle situations of this nature, or ensure that the appropriate error messaging is delivered.
This is another example of how virtualization can be used to your advantage. When you set up a virtual API, you can control the performance behavior so that you can simulate what happens when an API goes slow or even unresponsive in the middle of a long-running transaction. You can use virtualization to simulate any API and control its behavior, whether it’s your API or it belongs to someone else.
3. Prove SLA for third parties
In the connected world, third parties are a fundamental part of in the API economy. Whether you’re building APIs that depend on other APIs to function or working with client that integrates with a number of APIs, or your API is consumed by others — you need to understand the impact third parties can have on your API’s performance and how your performance can impact others.
One of the challenges of working with APIs is that it has been historically difficult to load test third party APIs and services. Often, companies will establish automatic IP restrictions to ensure a load test from outside their system doesn’t overwhelm their APIs, potentially causing service degradation.
It’s your responsibility to make sure that third parties can prove their SLA, verify this claim on your own, and to make sure they also have an established process for load testing their API. In addition to using virtualization to test the impact of poor performance of a third party API, you should also ask them to share the results of their own load tests to ensure they are properly testing their APIs.
Load Testing Requires the Right Tools
As you get started with your load testing, SmartBear has the tools you need to ensure that your APIs perform flawlessly under various traffic conditions. ReadyAPI is the industry’s leading API load testing tool that is great for beginners, because it’s scriptless and allows for easy reuse of your functional API tests from ReadyAPI.
ReadyAPI allows you to quickly get started and:
- Save time & resources by building load tests from pre-configured templates in just a few clicks
- Create real-life traffic patterns from servers ‘on premise’ or in the cloud
- Understand server performance by visualizing the effects of load on your servers with real-time monitoring
- Quickly analyze results by collecting advanced performance metrics for your load test runs and benchmarking them against past tests
- Reuse your existing functional test cases from ReadyAPI for increased efficiency