Validation error responses in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the class used for validation errors in FastAPI.

FastAPI

from fastapi.exceptions import [1]

Drag options to blanks, or click blank then click option'

ARequestValidationError

BHTTPException

CValidationError

DDepends

Attempts:

3 left

💡 Hint

Common Mistakes

Using HTTPException instead of RequestValidationError

Using ValidationError from Pydantic directly

The RequestValidationError class is used by FastAPI to represent validation errors in requests.

2fill in blank

medium

Complete the code to create a FastAPI exception handler for validation errors.

FastAPI

@app.exception_handler([1])
async def validation_exception_handler(request, exc):
    return JSONResponse(status_code=422, content={"detail": exc.errors()})

Drag options to blanks, or click blank then click option'

AHTTPException

BRequestValidationError

CValidationError

DValueError

Attempts:

3 left

💡 Hint

Common Mistakes

Using HTTPException instead of RequestValidationError

Using ValidationError from Pydantic

The @app.exception_handler decorator needs the RequestValidationError to catch validation errors.

3fill in blank

hard

Fix the error in the handler to return the validation errors correctly as JSON.

FastAPI

from fastapi.responses import JSONResponse

@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    return JSONResponse(status_code=422, content=[1])

Drag options to blanks, or click blank then click option'

A{"errors": exc.errors()}

B{"detail": exc.json()}

C{"detail": exc.errors()}

Dexc.errors()

Attempts:

3 left

💡 Hint

Common Mistakes

Returning exc.errors() directly without wrapping in a dict

Using exc.json() which returns a string, not a dict

The response content must be a dictionary with a detail key holding the list of errors.

4fill in blank

hard

Fill both blanks to import and use the correct JSON response class and error class for validation errors.

FastAPI

from fastapi.responses import [1]
from fastapi.exceptions import [2]

@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    return JSONResponse(status_code=422, content={"detail": exc.errors()})

Drag options to blanks, or click blank then click option'

AJSONResponse

BRequestValidationError

CHTTPException

DPlainTextResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using PlainTextResponse instead of JSONResponse

Using HTTPException instead of RequestValidationError

Use JSONResponse to send JSON data and RequestValidationError to catch validation errors.

5fill in blank

hard

Fill all three blanks to define a custom validation error handler that logs the error, returns JSON with status 422, and uses the correct imports.

FastAPI

from fastapi.exceptions import [1]
from fastapi.responses import [2]
import logging

logger = logging.getLogger(__name__)

@app.exception_handler([3])
async def validation_exception_handler(request, exc):
    logger.error(f"Validation error: {exc}")
    return JSONResponse(status_code=422, content={"detail": exc.errors()})

Drag options to blanks, or click blank then click option'

ARequestValidationError

BJSONResponse

DHTTPException

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing HTTPException with validation error handling

Forgetting to import JSONResponse

Import RequestValidationError from fastapi.exceptions, JSONResponse from fastapi.responses, and use RequestValidationError in the handler decorator.

Practice

1. What does FastAPI do when a request body fails validation by Pydantic models?

easy

A. It logs the error but returns a success response.

B. It automatically returns a detailed validation error response to the client.

C. It crashes the server with an unhandled exception.

D. It ignores the error and processes the request anyway.

Solution

1. Step 1: Understand FastAPI's validation mechanism

   FastAPI uses Pydantic models to validate incoming request data automatically.

2. Step 2: Observe default error handling

   If validation fails, FastAPI returns a JSON response describing the validation errors without crashing.

3. Final Answer:

   It automatically returns a detailed validation error response to the client. -> Option B

4. Quick Check:

   Validation failure triggers automatic error response = D [OK]

Hint: Validation errors trigger automatic JSON error responses [OK]

Common Mistakes:

• Thinking FastAPI crashes on validation errors
• Assuming errors are ignored silently
• Believing errors are only logged without response

2. Which import is required to customize validation error responses in FastAPI?

easy

A. from fastapi.responses import ValidationErrorResponse

B. from fastapi import RequestValidationError

C. from pydantic import ValidationError

D. from fastapi.exceptions import RequestValidationError

Solution

1. Step 1: Identify the correct module for RequestValidationError

   FastAPI's RequestValidationError is located in fastapi.exceptions, not directly in fastapi.

2. Step 2: Check other options

   Pydantic's ValidationError is different and not used for FastAPI's error handler. No ValidationErrorResponse class exists.

3. Final Answer:

   from fastapi.exceptions import RequestValidationError -> Option D

4. Quick Check:

   RequestValidationError import is from fastapi.exceptions = A [OK]

Hint: RequestValidationError is in fastapi.exceptions module [OK]

Common Mistakes:

• Importing RequestValidationError directly from fastapi
• Confusing Pydantic's ValidationError with FastAPI's
• Assuming a ValidationErrorResponse class exists

3. Given this FastAPI code snippet, what will be the response if the client sends {"age": "twenty"}?

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    age: int

@app.post("/user")
async def create_user(user: User):
    return {"age": user.age}

medium

A. 422 Unprocessable Entity with validation error details

B. {"age": "twenty"}

C. 200 OK with age set to 0

D. 500 Internal Server Error

Solution

1. Step 1: Analyze the Pydantic model validation

   The User model expects an integer for age, but the client sends a string "twenty" which cannot be converted to int.

2. Step 2: Understand FastAPI's response to invalid data

   FastAPI automatically returns a 422 status with a JSON body describing the validation error.

3. Final Answer:

   422 Unprocessable Entity with validation error details -> Option A

4. Quick Check:

   Invalid type triggers 422 validation error = A [OK]

Hint: Invalid data types cause 422 validation error response [OK]

Common Mistakes:

• Expecting the server to accept wrong types silently
• Assuming a 500 error instead of 422
• Thinking the response echoes invalid input

4. Identify the error in this FastAPI code that tries to customize validation error responses:

from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    return JSONResponse(status_code=400, content={"error": exc.errors()})

medium

A. The status_code 400 is incorrect; it should be 422 for validation errors.

B. The exception handler must return a Response, not JSONResponse.

C. The exc.errors() method does not exist on RequestValidationError.

D. The handler function must not be async.

Solution

1. Step 1: Check the correct HTTP status code for validation errors

   FastAPI uses 422 Unprocessable Entity for validation errors by default, not 400 Bad Request.

2. Step 2: Verify other parts of the handler

   Returning JSONResponse is valid, exc.errors() is a valid method, and async handlers are allowed.

3. Final Answer:

   The status_code 400 is incorrect; it should be 422 for validation errors. -> Option A

4. Quick Check:

   Validation errors use 422 status code, not 400 = B [OK]

Hint: Validation errors respond with 422 status code, not 400 [OK]

Common Mistakes:

• Using 400 instead of 422 status code
• Thinking exc.errors() is invalid
• Believing async is disallowed in handlers

5. How can you customize FastAPI to return a simpler validation error message like {"detail": "Invalid input"} instead of the default detailed errors?

hard

A. Set a global FastAPI config option to simplify validation errors.

B. Modify the Pydantic model to raise simpler errors automatically.

C. Override the default exception handler for RequestValidationError and return a custom JSONResponse with the simpler message.

D. Use middleware to catch validation errors and replace the response.

Solution

1. Step 1: Understand how to customize validation error responses

   FastAPI allows overriding the exception handler for RequestValidationError to customize error responses.

2. Step 2: Evaluate other options

   Pydantic models do not control error response format, no global config exists for this, and middleware is not the recommended way for validation errors.

3. Final Answer:

   Override the default exception handler for RequestValidationError and return a custom JSONResponse with the simpler message. -> Option C

4. Quick Check:

   Custom handler for RequestValidationError = C [OK]

Hint: Use custom exception handler to simplify validation error messages [OK]

Common Mistakes:

• Trying to change Pydantic model error output
• Looking for global config to simplify errors
• Using middleware instead of exception handlers