- Courses
- 📚Libraries & Frameworks
- ⚡FastAPI
- Advanced Features and Production Readiness
- Testing FastAPI Applications
On this page
FastAPI Testing – pytest, TestClient, Fixtures, and Dependency Overrides
Published on August 16, 2026
By Enrico Hochkoeppler
Web Developer & TutoriaLibre Founder
Testing a FastAPI application requires verifying two distinct concerns: that individual functions produce correct output in isolation (unit tests), and that API endpoints behave correctly end‑to‑end with the database, authentication, and business logic fully wired together (integration tests). Unit tests are fast and pinpoint logic errors. Integration tests catch the bugs that only surface when components interact — a dependency wired incorrectly, a database column mismatching the model, or an authentication check inadvertently bypassed. Both are essential.
This guide covers the complete testing setup for a FastAPI project: a shared conftest.py with reusable fixtures, an isolated in‑memory test database configured via app.dependency_overrides, unit tests for security functions, and integration tests that cover both successful paths and error responses. All code examples are production‑ready and follow current FastAPI and pytest best practices.
Installing Testing Dependencies​
FastAPI's TestClient is built on httpx (not requests — this changed in Starlette 0.20). Both pytest and httpx must be installed:
pip install pytest httpx
Verify the setup by running pytest from the project root:
python -m pytest -v
pytest automatically discovers any file whose name starts with test_ and any function within those files whose name starts with test_.
Unit Tests vs Integration Tests​
Unit TestIntegration TestWhat it testsA single function in complete isolationMultiple components working together through the full stackDependenciesMocked or absentReal (or test‑equivalent) — database, auth, routingSpeedVery fast (milliseconds)Slower (database I/O, bcrypt hashing)Examplehash_password() returns a non‑empty stringPOST /auth/login returns a JWT tokenFailure signalLogic error in one functionRegression in how components integrate
Unit tests catch logic bugs fast and early. Integration tests catch the bugs that only appear when components interact — a dependency wired incorrectly, a database column that does not match the model, or an authentication check that is bypassed. Both are necessary in a robust test suite.
Project Test Structure​
project/
├── main.py
├── db.py
├── core/
├── models/
├── routers/
├── services/
└── tests/
├── conftest.py # shared fixtures: client, test DB session, test user, auth token
├── test_auth.py # unit + integration tests for auth routes
├── test_tasks.py # integration tests for task CRUD and ownership
└── test_admin.py # role‑based access control tests
All shared setup belongs in conftest.py. pytest discovers this file automatically and makes its fixtures available to every test file in the same directory and below, without any imports.
conftest.py – Shared Fixtures​
This is the most important file in the test suite. It wires together three concerns: an isolated in‑memory database per test session, a TestClient that uses that database, and helper fixtures for creating authenticated users.
đź“„ tests/conftest.py
import pytest
from fastapi.testclient import TestClient
from sqlmodel import SQLModel, Session, create_engine
from sqlalchemy.pool import StaticPool
from main import app
from db import get_session
# --- Test database setup ---
TEST_DATABASE_URL = "sqlite://" # in‑memory SQLite, no file on disk
@pytest.fixture(name="engine", scope="session")
def engine_fixture():
engine = create_engine(
TEST_DATABASE_URL,
connect_args={"check_same_thread": False},
poolclass=StaticPool, # same connection for all threads — required for in‑memory SQLite
)
SQLModel.metadata.create_all(engine)
yield engine
SQLModel.metadata.drop_all(engine)
@pytest.fixture(name="session")
def session_fixture(engine):
with Session(engine) as session:
yield session
# --- Dependency override: replace the production DB session with the test session ---
@pytest.fixture(name="client")
def client_fixture(session: Session):
def override_get_session():
yield session
app.dependency_overrides[get_session] = override_get_session
app.state.limiter.enabled = False # disable rate limiting for all tests
with TestClient(app) as test_client:
yield test_client
app.dependency_overrides.clear()
# --- Auth helper fixtures ---
@pytest.fixture(name="test_user_token")
def test_user_token_fixture(client: TestClient) -> str:
"""Creates a test user and returns a valid Bearer token."""
client.post(
"/auth/signup",
json={
"username": "testuser",
"email": "[email protected]",
"hashed_password": "testpassword123",
},
)
response = client.post(
"/auth/login",
data={"username": "testuser", "password": "testpassword123"},
)
return response.json()["access_token"]
@pytest.fixture(name="auth_headers")
def auth_headers_fixture(test_user_token: str) -> dict:
return {"Authorization": f"Bearer {test_user_token}"}
Why dependency overrides for the database​
app.dependency_overrides[get_session] = override_get_session tells FastAPI to call override_get_session instead of get_session whenever a route or dependency injects a Session. Every test runs against a fresh in‑memory SQLite database that is created before the test session starts and dropped afterward.
This means:
- Tests never touch the development or production database
- Test runs are deterministic — no leftover data from previous runs
- Tests can run in any order without affecting each other
- The in‑memory database is faster than disk‑based SQLite
StaticPool is required when using an in‑memory SQLite database. Without it, SQLAlchemy creates a new connection (and therefore a new empty database) for every pool checkout. StaticPool reuses the same connection, so the schema and data created during setup persist throughout the test.
Unit Tests​
Unit tests verify pure functions in isolation, with no database, no HTTP client, and no external dependencies.
đź“„ tests/test_auth.py
from core.security import hash_password, verify_password
from core.jwt import create_access_token, decode_access_token
# --- Password hashing ---
def test_hash_password_returns_non_empty_string():
result = hash_password("mysecretpassword")
assert isinstance(result, str)
assert len(result) > 0
def test_hash_password_does_not_return_plaintext():
plain = "mysecretpassword"
result = hash_password(plain)
assert result != plain
def test_verify_password_correct_password():
plain = "mysecretpassword"
hashed = hash_password(plain)
assert verify_password(plain, hashed) is True
def test_verify_password_wrong_password():
hashed = hash_password("correctpassword")
assert verify_password("wrongpassword", hashed) is False
def test_verify_password_empty_string():
hashed = hash_password("realpassword")
assert verify_password("", hashed) is False
# --- JWT ---
def test_create_access_token_returns_string():
token = create_access_token({"sub": "testuser"})
assert isinstance(token, str)
assert len(token) > 0
def test_decode_access_token_returns_correct_subject():
token = create_access_token({"sub": "testuser"})
payload = decode_access_token(token)
assert payload is not None
assert payload["sub"] == "testuser"
def test_decode_access_token_invalid_token_returns_none():
result = decode_access_token("this.is.not.a.valid.token")
assert result is None
These tests exercise hash_password, verify_password, create_access_token, and decode_access_token directly. No TestClient, no database, no HTTP — just function inputs and outputs. They run in under a millisecond each and provide precise failure signals when the security logic breaks.
Integration Tests – Auth Endpoints​
đź“„ tests/test_auth.py (continued)
from fastapi.testclient import TestClient
# --- Signup ---
def test_signup_success(client: TestClient):
response = client.post(
"/auth/signup",
json={
"username": "newuser",
"email": "[email protected]",
"hashed_password": "password123",
},
)
assert response.status_code == 201
data = response.json()
assert "user_id" in data
assert isinstance(data["user_id"], int)
def test_signup_duplicate_username_returns_400(client: TestClient):
payload = {
"username": "duplicateuser",
"email": "[email protected]",
"hashed_password": "password123",
}
client.post("/auth/signup", json=payload) # first signup
response = client.post("/auth/signup", json=payload) # duplicate
assert response.status_code == 400
assert "already exists" in response.json()["detail"].lower()
# --- Login ---
def test_login_success(client: TestClient):
client.post(
"/auth/signup",
json={
"username": "loginuser",
"email": "[email protected]",
"hashed_password": "loginpassword",
},
)
response = client.post(
"/auth/login",
data={"username": "loginuser", "password": "loginpassword"},
)
assert response.status_code == 200
data = response.json()
assert "access_token" in data
assert data["token_type"] == "bearer"
def test_login_wrong_password_returns_401(client: TestClient):
client.post(
"/auth/signup",
json={
"username": "wrongpwuser",
"email": "[email protected]",
"hashed_password": "correctpassword",
},
)
response = client.post(
"/auth/login",
data={"username": "wrongpwuser", "password": "wrongpassword"},
)
assert response.status_code == 401
def test_login_nonexistent_user_returns_401(client: TestClient):
response = client.post(
"/auth/login",
data={"username": "ghostuser", "password": "anypassword"},
)
assert response.status_code == 401
def test_login_sends_form_data_not_json(client: TestClient):
"""OAuth2PasswordRequestForm requires form‑encoded data, not JSON."""
response = client.post(
"/auth/login",
json={"username": "anyuser", "password": "anypassword"},
)
assert response.status_code == 422
Why test error responses​
Testing only happy paths leaves the most consequential gaps. A 401 that returns 200 is a security hole. A 400 that returns 500 is a crash. Every error the API is supposed to produce must be asserted. The test for 422 on the login endpoint documents the OAuth2 requirement that credentials must be form‑encoded, not JSON — a mistake that is easy to make and should have a test guarding against regression.
Integration Tests – Task Lifecycle​
đź“„ tests/test_tasks.py
from fastapi.testclient import TestClient
import pytest
def test_create_task(client: TestClient, auth_headers: dict):
response = client.post(
"/tasks/",
json={"title": "Write tests", "description": "Cover all endpoints"},
headers=auth_headers,
)
assert response.status_code == 201
data = response.json()
assert data["title"] == "Write tests"
assert data["completed"] is False
assert "id" in data
def test_get_tasks_returns_only_own_tasks(client: TestClient, auth_headers: dict):
# Create a task as testuser
client.post(
"/tasks/",
json={"title": "My task"},
headers=auth_headers,
)
response = client.get("/tasks/", headers=auth_headers)
assert response.status_code == 200
tasks = response.json()
assert isinstance(tasks, list)
assert all("id" in t for t in tasks)
def test_get_task_without_auth_returns_401(client: TestClient):
response = client.get("/tasks/")
assert response.status_code == 401
def test_update_task(client: TestClient, auth_headers: dict):
create_res = client.post(
"/tasks/",
json={"title": "Original title"},
headers=auth_headers,
)
task_id = create_res.json()["id"]
update_res = client.put(
f"/tasks/{task_id}",
json={"title": "Updated title", "completed": True},
headers=auth_headers,
)
assert update_res.status_code == 200
assert update_res.json()["title"] == "Updated title"
assert update_res.json()["completed"] is True
def test_delete_task(client: TestClient, auth_headers: dict):
create_res = client.post(
"/tasks/",
json={"title": "Task to delete"},
headers=auth_headers,
)
task_id = create_res.json()["id"]
del_res = client.delete(f"/tasks/{task_id}", headers=auth_headers)
assert del_res.status_code == 204
get_res = client.get(f"/tasks/{task_id}", headers=auth_headers)
assert get_res.status_code == 404
def test_get_nonexistent_task_returns_404(client: TestClient, auth_headers: dict):
response = client.get("/tasks/999999", headers=auth_headers)
assert response.status_code == 404
def test_task_ownership_isolation(client: TestClient):
"""User A cannot see or modify User B's tasks."""
# Create User A
client.post(
"/auth/signup",
json={"username": "usera", "email": "[email protected]", "hashed_password": "passa"},
)
token_a = client.post(
"/auth/login", data={"username": "usera", "password": "passa"}
).json()["access_token"]
headers_a = {"Authorization": f"Bearer {token_a}"}
# Create User B
client.post(
"/auth/signup",
json={"username": "userb", "email": "[email protected]", "hashed_password": "passb"},
)
token_b = client.post(
"/auth/login", data={"username": "userb", "password": "passb"}
).json()["access_token"]
headers_b = {"Authorization": f"Bearer {token_b}"}
# User A creates a task
task_id = client.post(
"/tasks/", json={"title": "User A task"}, headers=headers_a
).json()["id"]
# User B cannot access User A's task
response = client.get(f"/tasks/{task_id}", headers=headers_b)
assert response.status_code == 404 # not 403 — ownership is opaque by design
Integration Tests – Role‑Based Access Control​
đź“„ tests/test_admin.py
from fastapi.testclient import TestClient
from sqlmodel import Session
from models.user import User
from core.security import hash_password
def test_admin_endpoint_rejects_regular_user(client: TestClient, auth_headers: dict):
response = client.get("/admin/users", headers=auth_headers)
assert response.status_code == 403
def test_admin_endpoint_rejects_unauthenticated(client: TestClient):
response = client.get("/admin/users")
assert response.status_code == 401
def test_admin_endpoint_allows_admin_user(client: TestClient, session: Session):
"""Create an admin user directly in the test DB and verify access."""
admin = User(
username="adminuser",
email="[email protected]",
hashed_password=hash_password("adminpassword"),
role="admin",
is_active=True,
)
session.add(admin)
session.commit()
token = client.post(
"/auth/login",
data={"username": "adminuser", "password": "adminpassword"},
).json()["access_token"]
response = client.get(
"/admin/users",
headers={"Authorization": f"Bearer {token}"},
)
assert response.status_code == 200
users = response.json()
assert isinstance(users, list)
Creating the admin user directly through the session fixture — instead of through the API — is intentional. The API has no admin‑creation endpoint (correctly), so tests that need an admin user seed one directly into the test database. This is a standard pattern in integration test suites.
Overriding Authentication for Unit‑Style Endpoint Tests​
When a test needs to verify route logic without going through the full authentication flow, dependency_overrides can replace get_current_user with a function that returns a hardcoded mock user:
from models.user import User
from core.dependencies import get_current_user
def test_get_tasks_with_mocked_auth(client: TestClient, session):
mock_user = User(id=1, username="mockuser", email="[email protected]",
hashed_password="x", role="user", is_active=True)
app.dependency_overrides[get_current_user] = lambda: mock_user
response = client.get("/tasks/")
assert response.status_code == 200
app.dependency_overrides.pop(get_current_user, None)
This pattern is useful for testing route handler logic when the authentication system itself is already covered by dedicated auth tests and you want to isolate the route under test from the token decode and database lookup that get_current_user performs.
Mocking External Services​
Background tasks and routes that call external APIs (email services, notification webhooks) should not make real network calls during tests. Use unittest.mock.patch to replace the external call with a mock that records whether it was called:
from unittest.mock import AsyncMock, patch
def test_signup_triggers_welcome_email(client: TestClient):
with patch("routers.auth.send_welcome_email", new_callable=AsyncMock) as mock_email:
response = client.post(
"/auth/signup",
json={
"username": "emailtestuser",
"email": "[email protected]",
"hashed_password": "password123",
},
)
assert response.status_code == 201
mock_email.assert_called_once_with("emailtestuser", "[email protected]")
patch replaces send_welcome_email in the routers.auth module for the duration of the with block. The mock records all calls and allows asserting that the email function was called with the correct arguments, without actually sending any email.
Running Tests​
# Run all tests
python -m pytest
# Run with verbose output showing each test name and result
python -m pytest -v
# Run a specific file
python -m pytest tests/test_auth.py -v
# Run a specific test function
python -m pytest tests/test_tasks.py::test_task_ownership_isolation -v
# Stop after the first failure
python -m pytest -x
# Show print() output during tests
python -m pytest -s
Common Testing Mistakes to Avoid​
Testing only happy paths. Every error the API is supposed to return — 400, 401, 403, 404, 422 — must have at least one test asserting it. A missing 401 check means a broken auth guard could go undetected.
Running integration tests against the development database. Without a get_session override, tests read and write real data, produce non‑deterministic results, and corrupt development state. Always use an isolated test database via dependency_overrides.
Putting setup logic in every test file. Creating the TestClient at module level in every file means there is no centralized control over test database configuration. Fixtures in conftest.py are the correct location for all shared setup.
Not cleaning up dependency_overrides after a test. Overrides set during one test leak into subsequent tests unless explicitly cleared. The client fixture in conftest.py calls app.dependency_overrides.clear() in its teardown, ensuring no test contaminates the next.
Testing the wrong client.post content type for OAuth2 endpoints. The /auth/login endpoint uses OAuth2PasswordRequestForm, which requires application/x‑www‑form‑urlencoded data. Use data={"username": ..., "password": ...} (not json=) in TestClient calls. Sending JSON produces a 422 response.
Making real external API calls in tests. Tests that call real external services are slow, flaky, and dependent on network availability. Patch them with unittest.mock.patch or pytest‑mock.
Practice Challenge​
- Write a unit test for
decode_access_tokenthat verifies an expired token returnsNone. Useunittest.mock.patchto mockdatetime.utcnow()and simulate token expiry. - Write an integration test that verifies
GET /tasks/with a valid token returns only the tasks created by the authenticated user — not tasks created by other users in the same test database. - Add a
pytest.iniorpyproject.toml[tool.pytest.ini_options]section that setstestpaths = ["tests"]andaddopts = "-v --tb=short"so verbose output is the default without typing flags.
Frequently Asked Questions​
What is the difference between unit tests and integration tests in FastAPI?
Unit tests verify a single function in complete isolation with no database, HTTP client, or external dependencies — for example, testing that hash_password returns a non‑plaintext string. Integration tests verify multiple components working together through the full request‑response stack — for example, testing that POST /auth/login returns a JWT token after querying the database and verifying the password. Unit tests are fast and produce precise failure signals. Integration tests catch bugs that only appear when components interact incorrectly.
How do I set up pytest for a FastAPI project?
Install pytest and httpx: pip install pytest httpx. Create a tests directory at the project root and place test files inside it. Name every test file with a test_ prefix and every test function with a test_ prefix. pytest discovers and runs them automatically. Create a conftest.py file in the tests directory for shared fixtures — this file is loaded automatically by pytest without any imports in the test files.
What is TestClient in FastAPI and how does it work?
TestClient is a synchronous HTTP client that runs the FastAPI application in‑memory without starting a real server. It is built on httpx and wraps the ASGI interface of the application directly. You create it by passing your FastAPI app: TestClient(app). Use it like an httpx client — client.get(), client.post(), and so on — and make assertions on the response status code and JSON body. httpx must be installed separately: pip install httpx.
Why should I install httpx to use FastAPI TestClient?
FastAPI TestClient is built on httpx, not the requests library. This changed in Starlette 0.20. Without httpx installed, importing TestClient raises an ImportError. Install it with pip install httpx before writing any tests. The TestClient API feels similar to requests, but the underlying transport layer is httpx, which supports both sync and async ASGI applications.
How do I use a test database instead of the production database in FastAPI tests?
Use app.dependency_overrides to replace the get_session dependency with a function that yields a session connected to an in‑memory SQLite database. In conftest.py, create an engine with create_engine('sqlite://', connect_args={'check_same_thread': False}, poolclass=StaticPool), call SQLModel.metadata.create_all(engine), and define an override_get_session function that yields a Session from that engine. Register it with app.dependency_overrides[get_session] = override_get_session before the TestClient is created. Clear overrides after each test with app.dependency_overrides.clear().
What is conftest.py in pytest and why should I use it for FastAPI tests?
conftest.py is a special pytest file that is automatically discovered and loaded without any imports. Fixtures defined inside it are available to all test files in the same directory and subdirectories. In a FastAPI project, conftest.py should define the shared TestClient fixture (with the database override wired in), the test database engine and session fixtures, and any auth helper fixtures such as a logged‑in user token. Putting setup in conftest.py eliminates duplication across test files and ensures teardown always runs.
What is app.dependency_overrides in FastAPI and how is it used in tests?
app.dependency_overrides is a dictionary on the FastAPI application instance that maps original dependency functions to replacement functions. During tests, you can replace any dependency — get_session, get_current_user, an external service client — with a test‑specific version. FastAPI calls the override instead of the original for the duration of the override. Always clear overrides after each test by calling app.dependency_overrides.clear() or by removing specific keys, so that one test does not contaminate the next.
How do I test a FastAPI endpoint that requires authentication?
First create a test user via POST /auth/signup, then log in via POST /auth/login using form data (data=, not json=) and extract the access_token from the response. Pass the token in the Authorization header of subsequent requests: headers={'Authorization': f'Bearer {token}'}. Define this flow as a pytest fixture in conftest.py so every test that needs an authenticated user receives a pre‑built headers dictionary without repeating the signup and login steps.
Why must I use data= instead of json= when testing the FastAPI login endpoint?
The login endpoint uses OAuth2PasswordRequestForm, which requires credentials submitted as application/x‑www‑form‑urlencoded form data, not JSON. When using TestClient, pass credentials with the data parameter: client.post('/auth/login', data={'username': '...', 'password': '...'}). Passing json= instead produces a 422 Unprocessable Entity response because the form parser finds no fields. This distinction is worth asserting explicitly in a test to guard against accidental regression.
How do I test that FastAPI returns the correct error status codes?
Write separate test functions for each error case and assert the expected status code on the response. For example, test that a duplicate signup returns 400, a missing token returns 401, a wrong role returns 403, a nonexistent resource returns 404, and a malformed request body returns 422. Asserting only 200 responses leaves the most consequential gaps — a broken auth guard or missing input validation may never be caught until it reaches production.
How do I test role‑based access control in FastAPI?
Write at least three tests for each admin‑only endpoint: one that sends no token and asserts 401, one that sends a regular user token and asserts 403, and one that sends an admin token and asserts 200. To create an admin user for testing, insert one directly into the test database via the session fixture — since there is no admin‑creation API endpoint, seeding the database directly is the standard approach for tests that need elevated‑privilege accounts.
Why is StaticPool required when using an in‑memory SQLite database in FastAPI tests?
SQLAlchemy creates a new connection for each pool checkout by default. With an in‑memory SQLite database ('sqlite://'), each new connection produces a new empty database. StaticPool forces SQLAlchemy to reuse the exact same connection across all checkouts, so the schema and data created during test setup persist throughout the test session. Without StaticPool, every route that checks out a session would see an empty database with no tables.
How do I mock an external API call in FastAPI tests?
Use unittest.mock.patch as a context manager around the test code. Patch the function at the location where it is used — typically the module where it is imported and called, not where it is defined. For async functions, use new_callable=AsyncMock. After the with block, use mock.assert_called_once() or mock.assert_called_once_with(...) to verify the external call was triggered with the correct arguments. This prevents tests from making real network requests and makes the test suite fast and deterministic.
How do I test task ownership in FastAPI — that one user cannot access another user's tasks?
Create two separate users with distinct credentials in the test, have User A create a task, then attempt to retrieve that task using User B credentials. Assert that the response is 404, not 403. The 404 is intentional — the service returns 404 whether the task does not exist or belongs to a different user, so that the existence of task IDs is not revealed to unauthorized callers. A test that asserts 403 in this scenario would be asserting incorrect behaviour.
How do I override get_current_user in FastAPI tests to skip authentication?
Set app.dependency_overrides[get_current_user] to a lambda or function that returns a hardcoded User object: app.dependency_overrides[get_current_user] = lambda: mock_user. FastAPI will inject the mock user into every route that depends on get_current_user, bypassing token decoding and the database lookup entirely. Remove the override after the test with app.dependency_overrides.pop(get_current_user, None) or call app.dependency_overrides.clear().
Why should I not run FastAPI integration tests against the development database?
Tests that use the development database produce non‑deterministic results because data from previous runs persists between test executions. A test that creates a user with a unique username will fail on the second run because the user already exists. Tests also corrupt development state — tasks, users, and other records created during testing mix with real development data. Use an in‑memory SQLite database via dependency_overrides for complete isolation that resets cleanly before every test session.
What pytest command options are most useful when running FastAPI tests?
python -m pytest -v shows each test name and pass/fail result individually. -x stops the run after the first failure, which is useful when debugging. -s shows print() output during tests. python -m pytest tests/test_auth.py runs a single file. python -m pytest tests/test_tasks.py::test_task_ownership_isolation runs a single test function. Adding testpaths = ['tests'] and addopts = '-v --tb=short' to pyproject.toml makes verbose output and short tracebacks the default without typing flags every time.
How do I test that a background task was called in FastAPI without actually running it?
Use unittest.mock.patch to replace the background task function with an AsyncMock before making the HTTP request. Because TestClient runs the background tasks synchronously after the response, the mock will have been called by the time the with block exits. Assert the call with mock.assert_called_once_with() passing the expected arguments. This verifies that the route correctly schedules the background task without executing the real task logic or making external network calls.
Found this helpful? Share the knowledge...
... or support this project to keep it alive!
Previous
WebSockets and Real-Time Features
Next
Building Your First API — Task Manager (Part 4)
-
Installing Testing Dependencies
-
Unit Tests vs Integration Tests
-
Project Test Structure
-
conftest.py– Shared Fixtures- Why dependency overrides for the database
-
Unit Tests
-
Integration Tests – Auth Endpoints
- Why test error responses
-
Integration Tests – Task Lifecycle
-
Integration Tests – Role‑Based Access Control
-
Overriding Authentication for Unit‑Style Endpoint Tests
-
Mocking External Services
-
Running Tests
-
Common Testing Mistakes to Avoid
-
Practice Challenge
-
Frequently Asked Questions
