If you have ever worked on writing UI automation tests, you probably came to the point when your test suite is so extensive that it takes a long time to run all the cases. And if the suite keeps on expanding, the situation won’t look better. Applications are growing and the number of tests will constantly increase. Luckily, there is a solution to speed up test runs. In this article, we present the advantages of using some help in the form of API testing in the UI test suite, focusing on the aspect of test execution time.

How can API Requests help you?

  • Tests will be easier to maintain – UI is constantly changing when API requests are persistent (for the most part)
  • You will get immediate tests result from the business logic side
  • You can find bugs and solve problems faster and in a more effective way
  • You will see a significant improvement in the test execution time

If there are some unwanted issues in the application, we want to be able to discover them as fast as possible. That’s why test execution time is significant in the development cycle. Before we focus on the API requests, first let’s take a small step back and take a look at the test from the UI side only.

Customer path

UI testing is literally the path that the customer is taking through the app, and it is crucial to write automation tests for these workflows. Sometimes we need to repeat the same steps in many feature files (especially if we are taking care of data independence) and it is not necessary to go over them again on UI side in each test. 

Imagine that as a customer you can configure your car through the app. You can start with choosing a basic model and then add some extra equipment for your vehicle. Let’s take a look at this example written in Gherkin: 

written in Gherkin

It is basic functionality, so we went through this workflow step by step on the UI side. In this test, we have many components that need to be fully loaded – pages, buttons, modals, and dropdowns. Every action takes some time – loading individual elements and clicking on them. It takes 51.63s. in total to run this scenario in PyCharm: 

scenario in PyCharm

API enters the stage 

Let’s now consider another case. What if customers change their minds about the color of the vehicle or they want to add or delete extra equipment? We need to be able to edit the order. Let’s create an additional test for this workflow.  

If we want to edit the vehicle, first we need to have one. We can start the Edit car test by creating a new vehicle using all the steps from the previous feature file, but we can also use API help here. Replacing repeatable steps with API requests will allow us to focus on the new functionality on the UI side. Let’s look at the Gherkin file for editing a car: 

Gherkin file for editing a car

In the first scenario of this feature, we are creating a car (via API) and in the second one editing the vehicle (through UI). In scenario “Create test car via API” we created the same car as in the previous feature “Create a car with additional equipment”, where everything was done on the UI side. If we look at the result now, we can see that the whole test (creating and editing a car) took less than 17 seconds: 

creating a car (via API)

Part for creating a vehicle by API took 11.107 seconds. To run these steps on the UI side we needed more than 50 seconds. To be precise we’ve just saved 40.513 seconds in one test! Imagine that we have another 10 or more tests that need that functionality – it can be a big time saver.

A request for help 

Key for benefit from API in UI test suite is to use popular Python library called Requests – it allows us to easily send HTTP requests. Basic POST requests can take the following form: 

 Basic POST requests

We have to start with importing the ‘requests’ module. Then we are declaring the URL of the request and data we want to send (provided as a dictionary). The next step is to make an HTTP request where we are passing our parameters (url is required, json – optional – it’s a JSON object which will be sent to the mentioned URL). In the end, we are returning the response from the server. 

In our car application, this example will be a little expanded. What exactly is hidden behind lines of code responsible for creating a vehicle via API requests? I will focus on the first step of this scenario: ‘Car “<car> from the model “<model>” and lacquer color “<color>” is created via API request’. If we look deeper, we can see step implementation:  

step implementation

And then if we go further to the car_is_created_via_api function, we can analyze requests sent to API:

car_is_created_via_api function

In car_is_created_via_api method, we are calling function _create_car which is responsible for requesting API. We are also passing parameters: car, model, and color. They will be used in the body of our request.  

As in the basic example, in_create_car function we are declaring URL (our car API) and body. Then we are making a POST request and in the final step, we are returning the response. 

After getting the response from the server, at the end of the car_is_created_function, we want to use assertion to check if we got the correct status code. Getting code 201 means that everything went as we hoped. Another result will tell us that something is wrong and we will be able to quickly (hopefully) find the gap in the code. 

Good Team


We went together through the advantages of using API help in the UI automation tests suite and a comparison of two approaches to testing. We also focused on speeding up tests suite execution time using Python library Requests. We believe that after reading this article you can see that API requests can be great companions and you are encouraged to start using this concept in your test automation projects.