Load Testing Using LOCUST

Any application's performance must be evaluated and improved through load testing. We utilise it to assess whether our application can survive the demands of actual use. Locust is a potent tool in every developer's toolbox for efficient load testing. With this free, open-source Python programme, you can simulate millions of concurrent users and describe user behaviour using Python code. This article will serve as your comprehensive, example-filled guide to load testing using Locust.

What is Locust?

A distributed, scalable, and user-friendly load testing tool is called locust. Simulating traffic patterns aids engineers in understanding how many concurrent users a system can support. The key benefit of using Python code to describe user behaviour is that Locust is extremely flexible and configurable.

Installing Locust

Make sure you have Python 3.6 or higher installed before you begin installing Locust. Pip may then be used to install Locust:

pip install locust

Getting Started with Locust

You must provide user behaviour in a Python file in order to utilise Locust for the first time. The actions that the simulated users will take are listed in this file, which is sometimes called locustfile.py.

from locust import HttpUser, task, between

class WebsiteUser(HttpUser):
   wait_time = between(5, 15)
    
   @task
   def homepage(self):
      self.client.get("/")

In this illustration, the behaviour of a simulated user is defined by WebsiteUser. The homepage task is executed after the user has waited between 5 and 15 seconds (wait_time = between(5, 15)) and sends a GET request to the home page (self.client.get("/")).

Running a Locust Test

Navigate to the directory containing your locustfile.py and issue the locust command to conduct a Locust test:

locust

The web interface for Locust then launches, and its address is http://localhost:8089. Here, you can define the destination website, the total number of users to simulate, and the spawn rate.

More Complex User Behavior

When imitating more complicated user behaviour, Locust truly shines.

Example 1: Multiple Tasks

In a single user class, many tasks can be defined. By default, Locust chooses at random which task to execute and distributes them evenly.

from locust import HttpUser, task, between

class WebsiteUser(HttpUser):
   wait_time = between(5, 15)
    
   @task(2)
   def homepage(self):
      self.client.get("/")
        
   @task(1)
   def about_page(self):
      self.client.get("/about/")

Due to the weight set (@task(2) and @task(1)), the homepage task in this example is twice as likely to be completed as the about_page task.

Example 2: POST Requests

Locust may also mimic POST requests, which are frequently used for sending form submissions.

from locust import HttpUser, task, between

class WebsiteUser(HttpUser):
   wait_time = between(5, 15)
    
   @task
   def login(self):
      self.client.post("/login/", {"username":"user", "password":"pass"})

In this illustration, the login task makes a POST request with a username and password to the /login/ URL.

Example 3: Sequential Tasks

The @seq_task decorator can be used for sequential jobs.

from locust import HttpUser, task, between, SequentialTaskSet

class UserBehavior(SequentialTaskSet):
    
   @task
   def homepage(self):
      self.client.get("/")
        
   @task
   def about_page(self):
      self.client.get("/about/")

class WebsiteUser(HttpUser):
   tasks = [UserBehavior]
   wait_time = between(5, 15)

Instead of extending HttpUser in this case, UserBehavior extends SequentialTaskSet. The homepage task is always carried out before the about_page task thanks to this class.

Conclusion

The software development lifecycle includes load testing, and Locust provides a flexible, user-friendly tool for efficient load testing. You can modify your load testing to meet the particular requirements of your application thanks to its web-based interface and Python-based user behaviour scripting. As you become more accustomed to the fundamental features, you can start to investigate more challenging tasks, POST requests, and sequential tasks.