FastAPI Testing
How do you test FastAPI applications?
FastAPI applications can be tested using the TestClient provided by FastAPI, which is built on top of Starlette's test client. It allows you to simulate HTTP requests and check responses without starting an actual server. You can use it to test routes, authentication, WebSockets, and more.
Example of using TestClient for testing:
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello World"}
client = TestClient(app)
def test_read_root():
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"message": "Hello World"}
In this example, the TestClient sends a GET request to the root endpoint and verifies the response status code and message.
How do you test routes in FastAPI?
To test routes in FastAPI, you use TestClient to simulate requests to your API and check the response. You can test different HTTP methods (GET, POST, PUT, DELETE) and verify status codes, response bodies, and headers.
Example of testing a POST route:
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
@app.post("/items/")
async def create_item(name: str):
return {"name": name}
client = TestClient(app)
def test_create_item():
response = client.post("/items/", json={"name": "Item1"})
assert response.status_code == 200
assert response.json() == {"name": "Item1"}
In this example, a POST request is made to create an item, and the response is checked to ensure the correct item is returned.
How do you test query parameters in FastAPI?
You can test query parameters by passing them as arguments in your test requests. TestClient allows you to easily pass query parameters and validate their handling in the application.
Example of testing query parameters:
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
@app.get("/items/")
async def read_item(skip: int = 0, limit: int = 10):
return {"skip": skip, "limit": limit}
client = TestClient(app)
def test_read_item():
response = client.get("/items/", params={"skip": 5, "limit": 15})
assert response.status_code == 200
assert response.json() == {"skip": 5, "limit": 15}
In this example, query parameters skip and limit are passed in the test, and the response is validated to check if the values were handled correctly.
How do you test request bodies in FastAPI?
To test request bodies in FastAPI, you can use the json argument in the TestClient methods like post, put, or patch. The request body is sent as a JSON object, and you can validate that the API correctly processes the incoming data.
Example of testing a request body:
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
@app.post("/users/")
async def create_user(user: dict):
return user
client = TestClient(app)
def test_create_user():
response = client.post("/users/", json={"name": "John", "age": 30})
assert response.status_code == 200
assert response.json() == {"name": "John", "age": 30}
In this example, a POST request is made with a JSON body containing user details, and the response is validated to ensure the correct data is returned.
How do you test authentication in FastAPI?
To test authentication in FastAPI, you can simulate sending authentication headers, such as bearer tokens or basic authentication, in your requests. You can also test login endpoints by sending credentials and verifying the response.
Example of testing authentication with a token:
from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from fastapi.testclient import TestClient
app = FastAPI()
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
def get_current_user(token: str = Depends(oauth2_scheme)):
if token != "valid-token":
raise HTTPException(status_code=401, detail="Invalid token")
return {"username": "user"}
@app.get("/users/me/")
async def read_users_me(current_user: dict = Depends(get_current_user)):
return current_user
client = TestClient(app)
def test_read_users_me():
response = client.get("/users/me/", headers={"Authorization": "Bearer valid-token"})
assert response.status_code == 200
assert response.json() == {"username": "user"}
In this example, a token is sent in the Authorization header to simulate an authenticated request. The test checks whether the token is valid and verifies the response.
How do you test WebSockets in FastAPI?
FastAPI supports WebSocket testing using the TestClient and WebSocket methods. You can use client.websocket_connect to establish a WebSocket connection and send or receive messages over the WebSocket.
Example of testing WebSockets:
from fastapi import FastAPI, WebSocket
from fastapi.testclient import TestClient
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
data = await websocket.receive_text()
await websocket.send_text(f"Message received: {data}")
client = TestClient(app)
def test_websocket():
with client.websocket_connect("/ws") as websocket:
websocket.send_text("Hello")
data = websocket.receive_text()
assert data == "Message received: Hello"
In this example, the test connects to the WebSocket, sends a message, and verifies that the server responds with the correct message.
How do you test background tasks in FastAPI?
FastAPI allows you to test background tasks using the BackgroundTasks class. You can test that the background task was properly added and executed as expected. In your tests, you can also mock the task function to ensure that it behaves correctly.
Example of testing background tasks:
from fastapi import FastAPI, BackgroundTasks
from fastapi.testclient import TestClient
app = FastAPI()
def mock_task():
print("Background task executed")
@app.post("/process/")
async def process_data(background_tasks: BackgroundTasks):
background_tasks.add_task(mock_task)
return {"message": "Task added"}
client = TestClient(app)
def test_process_data():
response = client.post("/process/")
assert response.status_code == 200
assert response.json() == {"message": "Task added"}
In this example, the test ensures that the background task is added and that the API behaves as expected when the task is queued.
How do you mock dependencies in FastAPI during testing?
In FastAPI, you can mock dependencies using the dependency_overrides feature. This allows you to override specific dependencies with mock implementations during testing, enabling you to isolate and test different parts of your application.
Example of mocking a dependency:
from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient
app = FastAPI()
def get_current_user():
return {"username": "user"}
@app.get("/users/me/")
async def read_users_me(current_user: dict = Depends(get_current_user)):
return current_user
client = TestClient(app)
def override_get_current_user():
return {"username": "test-user"}
app.dependency_overrides[get_current_user] = override_get_current_user
def test_read_users_me():
response = client.get("/users/me/")
assert response.status_code == 200
assert response.json() == {"username": "test-user"}
In this example, the get_current_user dependency is overridden during testing to return a mock user. The test verifies that the mock dependency is used correctly.
How do you test file uploads in FastAPI?
You can test file uploads in FastAPI by simulating a file upload in the test client using the files argument. The files argument takes a dictionary where the key is the file field name and the value is a tuple containing the file name, file content, and MIME type.
Example of testing file uploads:
from fastapi import FastAPI, UploadFile
from fastapi.testclient import TestClient
app = FastAPI()
@app.post("/uploadfile/")
async def upload_file(file: UploadFile):
return {"filename": file.filename}
client = TestClient(app)
def test_upload_file():
file = ("test.txt", b"file content", "text/plain")
response = client.post("/uploadfile/", files={"file": file})
assert response.status_code == 200
assert response.json() == {"filename": "test.txt"}
In this example, the test simulates a file upload and verifies that the file is received and processed by the API correctly.