Custom request validation in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a FastAPI endpoint uses a custom validator that raises a ValueError?

Consider this FastAPI endpoint with a Pydantic model that has a custom validator raising ValueError if a condition fails. What will the client receive if the validation fails?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel, validator

app = FastAPI()

class Item(BaseModel):
    name: str
    quantity: int

    @validator('quantity')
    def quantity_must_be_positive(cls, v):
        if v <= 0:
            raise ValueError('Quantity must be positive')
        return v

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

A The client receives a 422 Unprocessable Entity response with a JSON error explaining 'Quantity must be positive'.

B The server crashes with a ValueError and no response is sent to the client.

C The client receives a 500 Internal Server Error with no details.

D The client receives a 200 OK response with the invalid data echoed back.

💡 Hint

Think about how FastAPI handles validation errors raised by Pydantic.

FastAPI uses Pydantic for validation. When a validator raises ValueError, FastAPI catches it and returns a 422 response with details about the validation error.

📝 Syntax

intermediate

Which code snippet correctly implements a custom request validator in FastAPI using Pydantic?

Choose the code that correctly defines a Pydantic model with a custom validator for a field age that must be at least 18.

A

class User(BaseModel):
    age: int

    @validator('age')
    def check_age(cls, v):
        if v < 18:
            raise ValueError('Must be at least 18')
        return v

B

class User(BaseModel):
    age: int

    def check_age(self):
        if self.age < 18:
            raise ValueError('Must be at least 18')

C

class User(BaseModel):
    age: int

    @validate('age')
    def check_age(cls, v):
        if v < 18:
            raise ValueError('Must be at least 18')
        return v

D

class User(BaseModel):
    age: int

    @validator
    def check_age(cls, v):
        if v < 18:
            raise ValueError('Must be at least 18')
        return v

💡 Hint

Remember the correct decorator name and its usage in Pydantic.

The @validator decorator requires the field name as a string argument. Option A correctly uses @validator('age'). Option A uses a wrong decorator name, B is missing the decorator, and A misses the field name argument.

🔧 Debug

advanced

Why does this FastAPI custom validator not run and how to fix it?

Given this Pydantic model, the custom validator does not seem to run when the API receives data. What is the cause?

FastAPI

from pydantic import BaseModel, validator

class Product(BaseModel):
    price: float

    def validate_price(cls, v):
        if v <= 0:
            raise ValueError('Price must be positive')
        return v

A The validator must be a static method, so it needs <code>@staticmethod</code> decorator.

B The method should be named <code>check_price</code> instead of <code>validate_price</code>.

C The method is missing the <code>@validator('price')</code> decorator, so it is never called.

D The validator must return a boolean, not the value.

💡 Hint

Check how Pydantic knows which methods are validators.

In Pydantic, validators must be decorated with @validator('field_name') to be recognized and run. Without the decorator, the method is just a normal method and not called during validation.

❓ state_output

advanced

What is the response when a FastAPI endpoint uses a root validator that modifies data?

Given this Pydantic model with a root validator that changes the full_name field, what will the API return when posting {"first_name": "Jane", "last_name": "Doe"}?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel, root_validator

app = FastAPI()

class User(BaseModel):
    first_name: str
    last_name: str
    full_name: str = ''

    @root_validator
    def set_full_name(cls, values):
        values['full_name'] = f"{values.get('first_name', '')} {values.get('last_name', '')}"
        return values

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

A {"first_name": "Jane", "last_name": "Doe", "full_name": ""}

B 422 Unprocessable Entity error because full_name is empty by default

C 500 Internal Server Error due to root_validator modifying values

D {"first_name": "Jane", "last_name": "Doe", "full_name": "Jane Doe"}

💡 Hint

Think about what a root validator can do to the data before returning it.

The root validator runs after individual field validation and can modify the entire data dictionary. Here it sets full_name by combining first and last names. The API returns the updated data including the computed full_name.

🧠 Conceptual

expert

Which statement best describes how FastAPI handles custom request validation errors?

Choose the statement that correctly explains FastAPI's behavior when a custom validation error occurs in a Pydantic model used for request validation.

A FastAPI ignores validation errors raised by Pydantic and passes the invalid data to the endpoint function.

B FastAPI catches validation errors raised by Pydantic validators and automatically returns a 422 response with detailed error messages in JSON format.

C FastAPI converts all validation errors into 500 Internal Server Errors without details to avoid leaking information.

D FastAPI requires manual try-except blocks in each endpoint to catch validation errors and return responses.

💡 Hint

Recall how FastAPI integrates with Pydantic for validation.

FastAPI automatically handles Pydantic validation errors by returning a 422 status code with a JSON body describing the errors. This behavior is built-in and requires no manual error handling in endpoints.