Skip to main content

Performance testing in Tornado

Before we dive in, let's understand what performance testing is. Performance testing is a type of testing aimed at determining the speed, responsiveness, and stability of a system under a workload.

In the context of Tornado, a Python web server and web application framework, performance testing can be vital to ensure that your applications can handle expected traffic and respond quickly to requests.

Table of Contents​

  1. Basic Setup
  2. Creating a Simple Tornado Application
  3. Using Locust for Performance Testing
  4. Understanding the Test Results

Basic Setup ​

To start with, you need to have Python and Tornado installed on your machine. You can install Tornado using pip:

pip install tornado

For performance testing, we will be using a tool called Locust. You can install it with pip as well:

pip install locust

Creating a Simple Tornado Application ​

Let's create a simple Tornado application that we will use for performance testing. The application will have just one route (/) that returns a "Hello, world" message.

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Save this code in a file named app.py and run it with python app.py. Your application will be accessible at http://localhost:8888.

Using Locust for Performance Testing ​

Locust is an open-source load testing tool. In essence, it will simulate multiple users accessing your application and provide you with useful statistics about its performance.

Create a new file named locustfile.py with the following code:

from locust import HttpUser, task, between

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

This script defines a simulated user (WebsiteUser) that waits between 5 and 15 seconds (chosen randomly) between tasks. The only task this user performs is accessing the root route of our application.

To start the test, run Locust with locust -f locustfile.py. You can then open a web browser and go to http://localhost:8089 to start the test and see the results.

Understanding the Test Results ​

Locust provides several key metrics:

  • Requests/s: The number of HTTP requests that your application can handle per second.
  • Median (ms): The median response time.
  • 95th percentile (ms): 95% of the requests have a response time lower than this.

Use these metrics to understand the performance of your Tornado application under different loads and identify potential bottlenecks.

Remember, performance testing is just one part of ensuring the quality of your application. Don't neglect other types of testing and debugging. Happy testing!