Testing path operations in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the response status code when a GET request is made to this FastAPI path operation?

Consider this FastAPI path operation:

from fastapi import FastAPI
app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

What status code will the response have when requesting /items/5?

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

A 200

B 404

C 500

D 302

💡 Hint

By default, successful GET requests return a standard success status code.

FastAPI returns status code 200 for successful GET requests unless otherwise specified.

📝 Syntax

intermediate

Which option correctly defines a POST path operation with a JSON body in FastAPI?

Which of the following code snippets correctly defines a POST path operation that accepts a JSON body with a name field?

A

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str

@app.post("/items")
async def create_item(item: Item):
    return item

B

from fastapi import FastAPI
app = FastAPI()

@app.post("/items")
async def create_item(name: str):
    return {"name": name}

C

from fastapi import FastAPI
app = FastAPI()

@app.post("/items")
async def create_item():
    name = request.json()["name"]
    return {"name": name}

D

from fastapi import FastAPI
app = FastAPI()

@app.post("/items")
def create_item(item: dict):
    return item

💡 Hint

FastAPI uses Pydantic models to parse and validate JSON bodies.

Option A uses a Pydantic model to define the expected JSON body and correctly annotates the parameter.

❓ state_output

advanced

What is the output of this test client code for a FastAPI GET path operation?

Given this FastAPI app and test code, what will print(response.json()) output?

from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"user_id": user_id, "name": f"User{user_id}"}

client = TestClient(app)
response = client.get("/users/10")
print(response.json())

FastAPI

from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"user_id": user_id, "name": f"User{user_id}"}

client = TestClient(app)
response = client.get("/users/10")
print(response.json())

A {"user_id": 10, "name": "user10"}

B {"user_id": "10", "name": "User10"}

C {"user_id": 10, "name": "User10"}

D TypeError: Object of type int is not JSON serializable

💡 Hint

FastAPI automatically converts path parameters to the declared type and serializes the response to JSON.

The path parameter user_id is an int, so the returned JSON has user_id as an integer and the name is formatted with capital U.

🔧 Debug

advanced

Which option causes a 422 Unprocessable Entity error when testing this FastAPI POST path operation?

Given this FastAPI POST path operation:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    username: str
    age: int

@app.post("/users")
async def create_user(user: User):
    return user

Which test client request will cause a 422 error?

A client.post("/users", json={"username": "alice", "age": 30})

B client.post("/users", json={"username": "bob", "age": "thirty"})

C client.post("/users", json={"username": "carol", "age": 25})

D client.post("/users", json={"username": "dave", "age": 40})

💡 Hint

Check the data types expected by the Pydantic model.

Option B sends a string for age instead of an integer, causing validation to fail and a 422 error.

🧠 Conceptual

expert

What happens if you call a FastAPI path operation function directly instead of using TestClient?

Consider this FastAPI path operation:

from fastapi import FastAPI
app = FastAPI()

@app.get("/hello")
async def say_hello():
    return {"message": "Hello"}

What is the difference between calling await say_hello() directly in Python and calling client.get('/hello') using TestClient?

A TestClient returns the Python dict directly; calling the function returns a Response object.

B Both return the exact same Response object with status code and headers.

C Calling the function directly raises an error because it requires a request object; TestClient works fine.

D Calling the function directly returns the Python dict; TestClient returns a Response object with JSON content and status code.

💡 Hint

Think about what FastAPI does to convert function return values into HTTP responses.

Calling the path operation function directly returns the raw Python return value (a dict). TestClient simulates an HTTP request and returns a Response object with status code, headers, and JSON content.