Why WebSockets enable real-time communication in FastAPI - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

How do WebSockets maintain a connection?

In FastAPI, WebSockets allow continuous communication between client and server. How do WebSockets keep this connection open?

A They use HTTP polling to check for new messages every few seconds.

B They repeatedly open and close HTTP connections for each message sent.

C They send messages only when the client refreshes the page.

D They open a single TCP connection that stays open for ongoing message exchange.

💡 Hint

Think about a phone call that stays connected instead of hanging up after each sentence.

WebSockets create a single TCP connection that remains open, allowing messages to flow instantly both ways without reopening connections.

❓ component_behavior

intermediate

What happens when a FastAPI WebSocket receives a message?

Consider a FastAPI WebSocket endpoint that echoes messages back to the client. What is the expected behavior when the client sends a message?

FastAPI

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket('/ws')
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(f'Message received: {data}')

A The server closes the connection immediately after receiving the message.

B The server accepts the connection, receives the message, and sends back a confirmation with the message content.

C The server ignores the message and sends no response.

D The server crashes because it does not handle binary messages.

💡 Hint

Look at the send_text line and what it sends back.

The server accepts the WebSocket connection, waits for a text message, then sends back a confirmation including the received message.

📝 Syntax

advanced

Identify the syntax error in this FastAPI WebSocket code

Which option contains the correct syntax for accepting a WebSocket connection and receiving a text message?

FastAPI

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket('/ws')
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(f'Received: {data}')

A

def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(f'Received: {data}')

B

async def websocket_endpoint(websocket: WebSocket):
    websocket.accept()
    data = websocket.receive_text()
    websocket.send_text(f'Received: {data}')

C

async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(f'Received: {data}')

D

async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept
    data = await websocket.receive_text()
    await websocket.send_text(f'Received: {data}')

💡 Hint

Check for missing await keywords and function definitions.

Option C correctly uses async def and awaits all async calls. Option C misses awaits, C is not async, and D misses parentheses on accept.

❓ state_output

advanced

What is the output after multiple WebSocket messages?

Given this FastAPI WebSocket code that counts messages, what is the value of count after receiving three messages?

FastAPI

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket('/ws')
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    count = 0
    for _ in range(3):
        await websocket.receive_text()
        count += 1
    await websocket.send_text(f'Messages received: {count}')

A 'Messages received: 3'

B 'Messages received: 0'

C 'Messages received: 1'

D RuntimeError due to missing await in loop

💡 Hint

Count increments inside the loop for each message received.

The loop runs three times, each time receiving a message and increasing count by 1, so count is 3.

🔧 Debug

expert

Why does this FastAPI WebSocket code raise an error?

Examine this WebSocket endpoint code. Why does it raise a RuntimeError: Cannot call receive_text() after connection is closed?

FastAPI

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket('/ws')
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.close()
    data2 = await websocket.receive_text()

A Because the code tries to receive a message after closing the WebSocket connection.

B Because the WebSocket was never accepted before receiving messages.

C Because receive_text() requires a timeout parameter.

D Because the close() method is not awaited properly.

💡 Hint

Think about what happens after closing a connection.

After calling await websocket.close(), the connection is closed. Trying to receive another message causes a RuntimeError.