Custom exception handlers in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the correct FastAPI class.

FastAPI

from fastapi import [1]
app = [1]()

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

AResponse

BHTTPException

CRequest

DFastAPI

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Request or Response instead of FastAPI

Trying to instantiate HTTPException as the app

The FastAPI class is imported to create the app instance.

2fill in blank

medium

Complete the code to define a custom exception handler for HTTPException.

FastAPI

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

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

AException

BHTTPException

CResponse

DRequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using Request or Response instead of HTTPException

Using the base Exception class which is too broad

The HTTPException class is used to catch HTTP errors in FastAPI.

3fill in blank

hard

Fix the error in the custom exception handler to return a JSON response.

FastAPI

from fastapi.responses import [1]

@app.exception_handler(ValueError)
async def value_error_handler(request, exc):
    return [1](status_code=400, content={"error": str(exc)})

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

APlainTextResponse

BHTMLResponse

CJSONResponse

DRedirectResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using PlainTextResponse or HTMLResponse which do not send JSON

Forgetting to import JSONResponse

Use JSONResponse to send JSON content back to the client.

4fill in blank

hard

Fill both blanks to create a custom exception and handler that returns a JSON error message.

FastAPI

class CustomError(Exception):
    def __init__(self, message):
        self.message = message

@app.exception_handler([1])
async def custom_error_handler(request, exc):
    return JSONResponse(status_code=[2], content={"error": exc.message})

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

ACustomError

B400

CHTTPException

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Using HTTPException instead of CustomError in the handler decorator

Using wrong status code like 500

The handler catches CustomError and returns status code 400.

5fill in blank

hard

Fill all three blanks to raise a custom exception and handle it with a JSON response.

FastAPI

class MyException(Exception):
    def __init__(self, detail):
        self.detail = detail

@app.get("/error")
async def error_route():
    raise [1]("Something went wrong")

@app.exception_handler([2])
async def my_exception_handler(request, exc):
    return JSONResponse(status_code=[3], content={"error": exc.detail})

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

AMyException

BCustomError

C400

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Raising a different exception than handled

Using status code 500 instead of 400

The route raises MyException, which is handled by the custom handler returning status 400.

Practice

1. What is the main purpose of a custom exception handler in FastAPI?

easy

A. To catch specific errors and return user-friendly responses

B. To speed up the server response time

C. To automatically fix bugs in the code

D. To log all incoming requests

Solution

1. Step 1: Understand what exception handlers do

   They catch errors that happen during request processing.

2. Step 2: Identify the benefit of custom handlers

   They allow sending clear, friendly messages instead of default error pages.

3. Final Answer:

   To catch specific errors and return user-friendly responses -> Option A

4. Quick Check:

   Custom handlers improve user experience = B [OK]

Hint: Custom handlers catch errors and explain them clearly [OK]

Common Mistakes:

• Thinking they fix bugs automatically
• Confusing with logging or performance tools
• Assuming they speed up requests

2. Which of the following is the correct way to register a custom exception handler in FastAPI?

easy

A. app.add_exception_handler(MyException, handler_function)

B. app.register_handler(MyException, handler_function)

C. app.use_exception_handler(MyException, handler_function)

D. app.exception_handler(MyException, handler_function)

Solution

1. Step 1: Recall FastAPI method for adding handlers

   FastAPI uses add_exception_handler to register handlers.

2. Step 2: Check method names in options

   Only app.add_exception_handler(MyException, handler_function) uses the correct method name and parameters.

3. Final Answer:

   app.add_exception_handler(MyException, handler_function) -> Option A

4. Quick Check:

   Correct method is add_exception_handler = D [OK]

Hint: Use add_exception_handler to register custom handlers [OK]

Common Mistakes:

• Using wrong method names like register_handler
• Confusing decorator syntax with registration
• Passing wrong parameters order

3. Given this code snippet, what will be the HTTP status code returned when MyException is raised?

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

app = FastAPI()

class MyException(Exception):
    pass

@app.exception_handler(MyException)
async def my_exception_handler(request: Request, exc: MyException):
    return JSONResponse(status_code=418, content={"message": "Custom error occurred"})

@app.get("/test")
async def test():
    raise MyException()

medium

A. 404

B. 418

C. 200

D. 500

Solution

1. Step 1: Identify the status code in the handler

   The handler returns a JSONResponse with status_code=418.

2. Step 2: Understand what happens when exception is raised

   Raising MyException triggers the handler, which sends the 418 status.

3. Final Answer:

   418 -> Option B

4. Quick Check:

   Handler sets status 418 = A [OK]

Hint: Check the status_code in JSONResponse inside handler [OK]

Common Mistakes:

• Assuming default 500 error code
• Confusing 404 with missing route
• Ignoring custom status_code in handler

4. What is wrong with this FastAPI custom exception handler code?

from fastapi import FastAPI

app = FastAPI()

class CustomError(Exception):
    pass

@app.exception_handler(CustomError)
def handler(exc: CustomError):
    return {"error": "Something went wrong"}

medium

A. Return value must be a string, not a dict

B. Exception class must inherit from HTTPException

C. Handler function must be async and accept Request parameter

D. Decorator should be @app.add_exception_handler, not @app.exception_handler

Solution

1. Step 1: Check handler function signature

   FastAPI expects async handler with parameters (Request, Exception).

2. Step 2: Identify missing Request and async

   The handler lacks the Request parameter and is not async.

3. Final Answer:

   Handler function must be async and accept Request parameter -> Option C

4. Quick Check:

   Handler signature requires async and Request = C [OK]

Hint: Handler must be async and take Request as first argument [OK]

Common Mistakes:

• Making handler synchronous
• Omitting Request parameter
• Thinking exception must inherit HTTPException

5. You want to create a custom exception handler in FastAPI that returns a JSON response with a dynamic message and a 400 status code whenever ValueError is raised. Which code snippet correctly implements this?

hard

A. from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return JSONResponse(content={"error": str(exc)}, status=400)

B. from fastapi import FastAPI

app = FastAPI()

@app.exception_handler(ValueError)
def value_error_handler(exc: ValueError):
return {"error": str(exc), "status": 400}

C. from fastapi import FastAPI, Request

app = FastAPI()

@app.add_exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return {"error": str(exc), "status_code": 400}

D. from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return JSONResponse(status_code=400, content={"error": str(exc)})

Solution

1. Step 1: Check correct decorator and function signature

   Use @app.exception_handler with async function taking (Request, Exception).

2. Step 2: Verify JSONResponse usage and status code

   Return JSONResponse with status_code=400 and content with error message.

3. Step 3: Identify correct option

   from fastapi import FastAPI, Request from fastapi.responses import JSONResponse app = FastAPI() @app.exception_handler(ValueError) async def value_error_handler(request: Request, exc: ValueError): return JSONResponse(status_code=400, content={"error": str(exc)}) matches all requirements exactly.

4. Final Answer:

   A -> Option D

5. Quick Check:

   Correct async handler with JSONResponse and status_code=400 = A [OK]

Hint: Use async handler with JSONResponse and status_code param [OK]

Common Mistakes:

• Using synchronous handler
• Missing Request parameter
• Wrong decorator or status code parameter name
• Returning dict instead of JSONResponse