Original text:In-depth exploration of FastAPI unit testing: use TestClient to easily test your API-51CTO.COM
When using FastAPI for unit testing, an important tool is the TestClient class. The TestClient class allows us to simulate HTTP requests to a FastAPI application and test the application's response. This allows us to fully test the API without starting the server.
Below I will explain in detail how to use TestClient and common operations:
Install and import TestClient
First, make sure your project has the FastAPI and pytest libraries installed. Then, import the TestClient class from the FastAPI library:
copy
from fastapi.testclient import TestClientCreate TestClient instance
Before writing test cases, we need to create a TestClient instance. We can create it by passing the application instance to the TestClient constructor:
copy
from fastapi import FastAPI
app = FastAPI()
client = TestClient(app)With this, we create a TestClient instance client and pass our FastAPI application app to it.
Send HTTP request
TestClient provides various methods to send different types of HTTP requests, including get(), post(), put(), delete(), etc. You can use these methods to test different endpoints and functionality of the API.
Here is an example of using TestClient to send a GET request:
copy
response = client.get("/items/42")In this example, we send a GET request to the /items/42 endpoint using TestClient's get() method and store the response in the response variable.
assert response
Next, we can use assertions to verify that the response's content, status code, and other properties are as expected.
Here are some common assertion examples:
- Check the response status code:
copy
assert response.status_code == 200- Check the JSON content of the response:
copy
assert response.json() == {"item_id": 42, "name": "Example Item"}- Check the response headers:
copy
assert response.headers["content-type"] == "application/json"- Check the text content of the response:
copy
assert response.text == "Success"You can use appropriate assertions to validate different aspects of the response as needed.
Pass request parameters and payload
For some requests, you may need to pass query parameters, path parameters, request body payload, etc. TestClient allows you to pass this information using keyword arguments.
Here are some examples:
- Pass query parameters:
copy
response = client.get("/items", params={"category": "books"})- Pass path parameters:
copy
response = client.get("/items/{item_id}", params={"item_id": 42})- Pass the request body payload:
copy
payload = {"name": "Example Item"} response = client.post("/items", json=payload)You can use keyword parameters to pass query parameters, path parameters, and request body payloads based on specific request requirements. For example, use the params parameter to pass query parameters, and use the json parameter to pass the request body payload in JSON format.
Handle response
TestClient's response object provides a number of properties and methods to handle and access various parts of the response.
The following are some commonly used response processing operations:
- Access the contents of the response:
copy
content = response.content- Get the JSON content of the response:
copy
json_data = response.json()- Get the response header information:
copy
headers = response.headers- Check if the response was successful:
copy
assert response.ok- Get the status code of the response:
copy
status_code = response.status_codeYou can handle and access the response using appropriate methods and properties based on your testing needs.
Complete example
Here is a complete example showing how to use TestClient to unit test a FastAPI application:
copy
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
@app.get("/items/{item_id}")
def read_item(item_id: int):
return {"item_id": item_id}
client = TestClient(app)
def test_read_item():
response = client.get("/items/42")
assert response.status_code == 200
assert response.json() == {"item_id": 42}In this example, we define a simple GET route handler function read_item, which accepts an item_id path parameter and returns the corresponding JSON response. We then use TestClient to send a GET request to the /items/42 endpoint and use assertions to verify that the response's status code and JSON content are as expected.
Execute tests
To perform the tests in the above example, you can use pytest to run the test files. In the command line, go to the directory where the test file is located and run the following command:
copy
pytest test_example.pypytest will automatically discover and run test cases and display the test results.
This is a detailed explanation of TestClient. By using TestClient, you can easily simulate HTTP requests and test various parts of the FastAPI application to ensure the correctness and consistency of its functionality.