Event-driven architecture in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when an event is emitted and handled in FastAPI?

Consider this FastAPI code snippet using an event system:

from fastapi import FastAPI
app = FastAPI()

subscribers = []

def on_event(data):
    subscribers.append(data)

@app.post('/emit')
async def emit_event(payload: dict):
    on_event(payload['message'])
    return {'status': 'event received'}

@app.get('/subscribers')
async def get_subscribers():
    return {'messages': subscribers}

What will be the output of a GET request to /subscribers after posting {"message": "hello"} to /emit once?

FastAPI

from fastapi import FastAPI
app = FastAPI()

subscribers = []

def on_event(data):
    subscribers.append(data)

@app.post('/emit')
async def emit_event(payload: dict):
    on_event(payload['message'])
    return {'status': 'event received'}

@app.get('/subscribers')
async def get_subscribers():
    return {'messages': subscribers}

A {"messages": ["hello"]}

B {"messages": []}

C {"messages": ["{'message': 'hello'}"]}

D {"messages": [null]}

💡 Hint

Think about what the on_event function does with the data it receives.

The on_event function appends the message string to the subscribers list. Posting to /emit triggers this function with the message "hello". So, the /subscribers endpoint returns the list containing "hello".

❓ lifecycle

intermediate

When does FastAPI's startup event run in an event-driven app?

In FastAPI, you can register a function to run on startup using @app.on_event('startup'). When exactly does this function run?

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.on_event('startup')
async def startup_event():
    print('App is starting')

A Only when the first request is received

B Every time a client sends a request

C When the FastAPI server starts before handling any requests

D When the server shuts down

💡 Hint

Think about the server lifecycle phases: startup, running, shutdown.

The startup event runs once when the FastAPI server starts, before it handles any requests. It is used to prepare resources or initialize state.

🔧 Debug

advanced

Why does this FastAPI event handler not update the shared state?

Look at this FastAPI code:

from fastapi import FastAPI
app = FastAPI()

state = {'count': 0}

def increment():
    state = {'count': state['count'] + 1}

@app.post('/inc')
async def increment_endpoint():
    increment()
    return state

Why does calling /inc never increase count?

FastAPI

from fastapi import FastAPI
app = FastAPI()

state = {'count': 0}

def increment():
    state = {'count': state['count'] + 1}

@app.post('/inc')
async def increment_endpoint():
    increment()
    return state

A FastAPI does not allow modifying global variables inside functions

B The increment function creates a new local variable 'state' instead of modifying the global one

C The state dictionary is immutable and cannot be changed

D The increment function is never called

💡 Hint

Check variable scope and assignment inside the increment function.

Inside increment, assigning to state creates a new local variable, shadowing the global state. The global state remains unchanged, so the count never increases.

📝 Syntax

advanced

Which FastAPI event handler code will raise a SyntaxError?

Identify the option that contains a syntax error in defining an event handler in FastAPI.

A

@app.on_event('startup')
async def startup_event()
    print('Starting up')

B

@app.on_event('startup')
async def startup_event():
    print('Starting up')

C

@app.on_event('shutdown')
async def shutdown_event():
    print('Shutting down')

D

@app.on_event('shutdown')
def shutdown_event():
    print('Shutting down')

💡 Hint

Look carefully at function definitions and punctuation.

Option A is missing a colon at the end of the function definition line, causing a SyntaxError.

🧠 Conceptual

expert

What is a key benefit of event-driven architecture in FastAPI apps?

Choose the best explanation of why event-driven architecture is useful in FastAPI applications.

A It forces all code to run synchronously, simplifying debugging

B It requires fewer lines of code by removing all function definitions

C It eliminates the need for any shared state or data storage

D It allows decoupling components so they react to events independently, improving scalability and maintainability

💡 Hint

Think about how events help parts of an app communicate without tight connections.

Event-driven architecture lets components respond to events independently, which helps scale the app and makes it easier to change parts without breaking others.