Statelessness requirement in Rest API - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this REST API statelessness simulation?

Consider a simple REST API simulation where each request is independent. The server does not store any client session data. What will be the output of the following code simulating two requests?

Rest API

class Server:
    def __init__(self):
        self.data = {}

    def handle_request(self, request):
        # Each request includes all needed info
        if request.get('action') == 'store':
            key = request.get('key')
            value = request.get('value')
            # Store data only for this request
            return f"Stored {key}={value}"
        elif request.get('action') == 'retrieve':
            key = request.get('key')
            # No stored data from previous requests
            return f"Value for {key}: None"

server = Server()

# First request stores data
print(server.handle_request({'action': 'store', 'key': 'x', 'value': '10'}))
# Second request tries to retrieve data
print(server.handle_request({'action': 'retrieve', 'key': 'x'}))

A Stored x=10\nValue for x: 10

B Stored x=10\nValue for x: None

C Value for x: None\nStored x=10

D Value for x: 10\nStored x=10

💡 Hint

Remember that stateless means the server does not keep data between requests.

The server does not save data between requests. So, even though the first request stores a value, the second request cannot retrieve it and returns None.

🧠 Conceptual

intermediate

Which statement best describes statelessness in REST APIs?

Choose the statement that correctly explains the statelessness requirement in REST APIs.

A Each request from client to server must contain all information needed to understand and process the request.

B The server must store session data to track client state between requests.

C Clients should never send authentication information with requests.

D The server maintains a continuous connection to remember client data.

💡 Hint

Think about how REST APIs handle client data across multiple requests.

Statelessness means the server does not keep client context between requests. Each request must be self-contained.

🔧 Debug

advanced

Why does this REST API server violate statelessness?

Examine the code below. Why does this server violate the statelessness requirement?

Rest API

class Server:
    def __init__(self):
        self.sessions = {}

    def handle_request(self, request):
        session_id = request.get('session_id')
        if session_id not in self.sessions:
            self.sessions[session_id] = {'count': 0}
        self.sessions[session_id]['count'] += 1
        return f"Request count: {self.sessions[session_id]['count']}"

A The server stores session data in self.sessions, keeping client state between requests.

B The server does not handle requests properly because it lacks a session_id.

C The server returns the wrong count value due to a syntax error.

D The server is stateless because it uses session_id in requests.

💡 Hint

Check if the server keeps any data between requests.

The server stores session data in a dictionary attribute, which means it keeps client state between requests. This breaks statelessness.

❓ Predict Output

advanced

What error does this stateless REST API code produce?

What error will this code produce when handling a request missing required data?

Rest API

def handle_request(request):
    # Expect 'user_id' in request
    user_id = request['user_id']
    return f"User ID is {user_id}"

print(handle_request({'action': 'get_data'}))

A No error, prints 'User ID is None'

B ValueError: invalid user_id

C KeyError: 'user_id'

D TypeError: missing 1 required positional argument

💡 Hint

What happens if you try to access a dictionary key that does not exist?

Accessing a missing key in a dictionary with square brackets raises a KeyError.

🚀 Application

expert

How many items are stored in the server after these stateless requests?

A REST API server is designed to be stateless. It receives three requests in order:

1. {"action": "add", "item": "apple"}
2. {"action": "add", "item": "banana"}
3. {"action": "list"}

The server code is:

class Server:
    def __init__(self):
        pass

    def handle_request(self, request):
        if request['action'] == 'add':
            # Does not store items
            return f"Added {request['item']}"
        elif request['action'] == 'list':
            # Always returns empty list
            return []

server = Server()
print(server.handle_request({"action": "add", "item": "apple"}))
print(server.handle_request({"action": "add", "item": "banana"}))
print(server.handle_request({"action": "list"}))

How many items will the server list after these requests?

A Cannot determine

B 1

C 2

D 0

💡 Hint

Think about whether the server keeps any data between requests.

The server does not store any items between requests, so the list action always returns an empty list with 0 items.