Field validation rules in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a FastAPI endpoint receives invalid data for a field with a length constraint?

Consider a FastAPI model with a field defined as name: str = Field(..., min_length=3, max_length=5). What will the API response be if a client sends {"name": "Jo"}?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()

class User(BaseModel):
    name: str = Field(..., min_length=3, max_length=5)

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

A The API returns a 422 Unprocessable Entity error with a message about the name being too short.

B The API accepts the data and returns the user object with the name "Jo".

C The API returns a 400 Bad Request error without details.

D The API ignores the length constraints and truncates the name to 3 characters.

💡 Hint

Think about how Pydantic validates fields before the endpoint logic runs.

FastAPI uses Pydantic to validate input data. If the name field is shorter than the min_length, Pydantic raises a validation error. FastAPI then returns a 422 error with details about the validation failure.

📝 Syntax

intermediate

Which option correctly applies a regex pattern validation to a FastAPI model field?

You want to ensure a field email matches a simple email pattern using FastAPI and Pydantic. Which code snippet correctly applies this validation?

A email: str = Field(..., regex=r"^[\w\.-]+@[\w\.-]+\.\w+$")

B email: str = Field(..., pattern=r"^[\w\.-]+@[\w\.-]+\.\w+$")

C email: str = Field(..., match=r"^[\w\.-]+@[\w\.-]+\.\w+$")

D email: str = Field(..., validate=r"^[\w\.-]+@[\w\.-]+\.\w+$")

💡 Hint

Check the correct keyword argument for regex validation in Pydantic's Field.

The correct keyword is regex. Other options like pattern, match, or validate are not valid parameters for Field.

❓ state_output

advanced

What is the value of the field after validation with a default and a custom validator?

Given this FastAPI model, what will be the value of username if the client sends {} (empty JSON)?

FastAPI

from pydantic import BaseModel, Field, validator

class User(BaseModel):
    username: str = Field("guest", min_length=3)

    @validator('username')
    def uppercase_username(cls, v):
        return v.upper()

A None

B "GUEST"

C ValidationError because min_length=3 is not met

D "guest"

💡 Hint

Think about how default values and validators interact in Pydantic.

The default value "guest" meets the min_length=3 constraint. The validator converts it to uppercase, so the final value is "GUEST".

🔧 Debug

advanced

Why does this FastAPI field validation fail with a TypeError?

Examine the code below. Why does it raise a TypeError when trying to validate the age field?

FastAPI

from pydantic import BaseModel, Field

class Person(BaseModel):
    age: int = Field(..., gt=0, lt="100")

A The <code>age</code> field must be optional to use <code>gt</code> and <code>lt</code>.

B The <code>gt</code> parameter cannot be used with <code>lt</code>.

C The <code>Field</code> function does not accept <code>gt</code> or <code>lt</code> parameters.

D The <code>lt</code> parameter must be an integer, not a string.

💡 Hint

Check the types of the parameters passed to Field.

The lt parameter expects a number, but a string "100" was given, causing a TypeError. Both gt and lt must be numbers.

🧠 Conceptual

expert

Which statement about FastAPI field validation with Pydantic is true?

Choose the correct statement about how FastAPI uses Pydantic for field validation.

A Field constraints like <code>min_length</code> are enforced only at runtime inside endpoint functions.

B Pydantic validators run before default values are applied to fields.

C Custom validators can modify field values after built-in validations pass.

D FastAPI ignores Pydantic field validations if the request body is empty.

💡 Hint

Think about the order of validation and transformation in Pydantic models.

Custom validators run after Pydantic applies built-in validations and default values. They can modify or transform field values. Other options are false because defaults apply before validators, constraints are enforced during parsing, and FastAPI returns errors for empty bodies when required.