Testing is just as important as any other phase of the software development life cycle, yet many developers tend to neglect it.
In this article, I’ll go through the implementation of some simple unit tests for a small Flask application that supports two routes.
The Flask application I’ll be writing tests for can be found in this repo: https://github.com/em-r/flask-schema-example
Install Pytest
After cloning the repo, setting up a virtual environment, and installing the requirements, let’s now install Pytest:
$ pip3 install pytest
Let’s now create a new folder in the root of the project where our tests will live:
$ mkdir testing
$ touch testing/__init__.py
Our project tree should look like this now:
Routes
As noted at the beginning of the article, this app is exposing just 2 routes:
- ‘/’: A route that allows only GET requests and serves back a JSON response.
- ‘/service’: A route that allows only POST requests, checks the request body if it’s a valid JSON, and serves back a JSON response.
Testing “/” route
Let’s kick things off by writing some tests for the index route.
In the /testing folder, create a new Python module and call it test_home.py:
$ touch testing/test_home.py
We are going to start by importing pytest and the Flask app instance.
The first thing we are going to implement is a Pytest fixture, which is just a Python function that we can use as a setup/teardown function for the actual tests.
This fixture will be passed as an argument to the test function that we are going to implement later.
In our case, the client fixture will return a FlaskClient instance that we can use to simulate HTTP requests to our Flask app.
By writing tests for this route, we want to ensure that it:
- Only allows GET requests.
- Returns a JSON response body that has one field called “message” which maps to the string “Hello Flask!”
We passed to both test functions an argument called client (same name as the fixture), which will represent the return value of the client fixture and will be used to interact with the Flask instance.
Here’s what’s going for both tests:
- test_home:
In this test, we want to make sure that for GET requests, the route will return a successful response (Line 11) that has a JSON body (Line 12) which should match what we returned in the home route implementation (Line 13).
- test_home_bad_http_method:
In this test, we want to make sure that the route allows only GET requests and returns a Method Not Allowed response for other HTTP verbs (Line 17).
To run those tests, run the following in command in your CLI:
$ pytest testing/test_home.py
Running those tests renders the following results:
Our two tests passed successfully.
Testing “/service” route
Just like for the index route, create a new Python module and call it this time test_service.py:
$ touch testing/test_service.py
We will be using the same procedure as previously (imports, creating the client fixture).
By writing tests for this route, we want to ensure that it:
- Only allows POST requests.
- Checks if the request body respects a pre-defined schema (required username and email_address fields).
- Returns a JSON response body that has one field called “success” which maps to the boolean value of True.
To accomplish this, we are going to write 4 tests:
Here’s what’s going for each test:
- test_service:
In this test, we want to make sure that for POST requests, the route will return a successful response (Line 11) that has a JSON body that should match what we returned in the service route implementation (Line 12).
- test_service_bad_http_method:
In this test, we want to make sure that the route allows only POST requests and returns a Method Not Allowed response for other HTTP verbs (Line 16) by simulating a GET request (Line 15).
- test_service_no_json_body:
In this test, we want to make sure that the route handler checks if the request has a JSON body and if not, returns a Bad Request response (Line 20).
- test_service_missing_email:
In this test, we want to make sure that the route handler verifies that the request body respects the pre-defined schema (Line 25) by simulating a POST request where we leave out the email_address field from the request body (Line 24).
To run those tests, run the following in command in your CLI:
$ pytest testing/test_service.py
Running those tests renders the following results:
As expected, all the tests passed successfully.
In this article, we went through the implementation of some very basic unit tests.
Hopefully, this will give an idea of how to implement more complex ones.
The code I used for this article can be found in this Github repository: https://github.com/em-r/flask-testing-blog
