Statelessness requirement in Rest API - Mini Project: Build & Apply

Statelessness Requirement in REST API

📖 Scenario: You are building a simple REST API for a book store. The API should follow the statelessness principle, which means each request from the client must contain all the information needed to process it. The server should not remember anything about previous requests.

🎯 Goal: Create a REST API endpoint that returns book details based on a book ID sent in the request. The API must not store any client session or state between requests.

📋 What You'll Learn

Create a dictionary called books with three books and their details

Create a variable called requested_book_id to simulate the client sending a book ID

Write a function called get_book_details that takes book_id as input and returns the book details from books

Print the result of calling get_book_details with requested_book_id

💡 Why This Matters

🌍 Real World

Statelessness is a key rule in REST APIs to make sure each request is independent. This helps servers handle many clients easily and reliably.

💼 Career

Understanding statelessness is important for backend developers and API designers to build scalable and maintainable web services.

1

Create the books data

Create a dictionary called books with these exact entries: 1: {'title': '1984', 'author': 'George Orwell'}, 2: {'title': 'To Kill a Mockingbird', 'author': 'Harper Lee'}, 3: {'title': 'The Great Gatsby', 'author': 'F. Scott Fitzgerald'}

Rest API

# Create the books dictionary with 3 books
# Your code here

Hint

Use a dictionary with integer keys and dictionary values for book details.

2

Simulate client request with book ID

Create a variable called requested_book_id and set it to 2 to simulate the client sending a book ID in the request

Rest API

books = {
    1: {'title': '1984', 'author': 'George Orwell'},
    2: {'title': 'To Kill a Mockingbird', 'author': 'Harper Lee'},
    3: {'title': 'The Great Gatsby', 'author': 'F. Scott Fitzgerald'}
}
# Create requested_book_id variable and set it to 2
# Your code here

Hint

Just assign the number 2 to requested_book_id.

3

Write the function to get book details

Write a function called get_book_details that takes a parameter book_id and returns the book details from the books dictionary using book_id

Rest API

def get_book_details(book_id):
    return books.get(book_id, 'Book not found')
# Print the book details below

Hint

Use the dictionary get method to safely get the book details or a default message.

4

Print the book details for the requested book

Print the result of calling get_book_details with requested_book_id

Rest API

Hint

Use print(get_book_details(requested_book_id)) to show the book details.

Practice

1. What does the statelessness requirement in REST APIs mean?

easy

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

B. The server must remember all previous requests from the client.

C. The server stores user session data between requests.

D. The client does not need to send any authentication information after the first request.

Solution

1. Step 1: Understand statelessness in REST

   Statelessness means the server does not keep any client context between requests.

2. Step 2: Identify what each request must contain

   Each request must have all data needed to process it, including authentication and parameters.

3. Final Answer:

   Each request from client to server must contain all information needed to understand and process it. -> Option A

4. Quick Check:

   Statelessness = All info in each request [OK]

Hint: Remember: server forgets past requests, all info sent every time [OK]

Common Mistakes:

• Thinking server stores session data
• Assuming client sends partial info only once
• Confusing statelessness with authentication persistence

2. Which of the following HTTP request examples follows the statelessness principle?

easy

A. POST /login HTTP/1.1\nHost: example.com\nCookie: sessionid=abc123

B. GET /profile HTTP/1.1\nHost: example.com

C. GET /profile HTTP/1.1\nHost: example.com\nReferer: /home

D. GET /profile HTTP/1.1\nHost: example.com\nAuthorization: Bearer token123

Solution

1. Step 1: Check if request contains all needed info

   GET /profile HTTP/1.1\nHost: example.com\nAuthorization: Bearer token123 includes Authorization header, so server can authenticate without stored session.

2. Step 2: Compare with other options

   POST /login HTTP/1.1\nHost: example.com\nCookie: sessionid=abc123 relies on cookies, which imply server state. Options B and D lack explicit authentication info.

3. Final Answer:

   GET request with Authorization header carrying token -> Option D

4. Quick Check:

   Auth info in request = stateless [OK]

Hint: Look for Authorization header in request to confirm statelessness [OK]

Common Mistakes:

• Assuming cookies mean statelessness
• Ignoring missing auth info in requests
• Confusing Referer header with authentication

3. Consider this REST API server behavior: It does not store any client session data. A client sends two requests:
1. GET /data?user=123&token=abc
2. GET /data?user=123
What will happen on the second request?

medium

A. The server rejects the request due to missing authentication token.

B. The server processes the request successfully using stored session data.

C. The server processes the request ignoring authentication.

D. The server crashes because of missing parameters.

Solution

1. Step 1: Analyze statelessness and authentication

   Since server is stateless, it does not remember previous tokens; each request must include token.

2. Step 2: Check second request parameters

   Second request lacks token parameter, so server cannot authenticate and must reject it.

3. Final Answer:

   Server rejects request due to missing authentication token. -> Option A

4. Quick Check:

   Missing token means reject request [OK]

Hint: Every request needs auth info; missing it causes rejection [OK]

Common Mistakes:

• Assuming server remembers token from first request
• Thinking server ignores missing token
• Believing server crashes on missing params

4. A developer wrote this REST API code snippet to handle user requests:

def handle_request(request):
    if 'session_id' in server_memory:
        user = server_memory['session_id']
        return f"Hello, {user}!"
    else:
        return "Unauthorized"

What is the main problem related to statelessness here?

medium

A. The code does not check for authentication token in the request.

B. The code correctly implements statelessness by using server memory.

C. The code stores session data on the server, violating statelessness.

D. The code uses request parameters properly for authentication.

Solution

1. Step 1: Identify server memory usage

   The code checks 'session_id' in server_memory, meaning it stores client state on server.

2. Step 2: Compare with statelessness principle

   Statelessness forbids server from storing client session data between requests.

3. Final Answer:

   Code stores session data on server, violating statelessness. -> Option C

4. Quick Check:

   Server storing session = stateful, not stateless [OK]

Hint: Stateless means no server memory of client sessions [OK]

Common Mistakes:

• Thinking server memory use is allowed
• Ignoring missing token checks
• Assuming code is stateless because it returns a string

5. You are designing a REST API for a shopping cart. To keep it stateless, which approach is best to track the user's cart items across requests?

hard

A. Store the cart items in a server-side session linked to the user ID.

B. Require the client to send the full cart data with each request.

C. Save the cart data in a database and keep session ID on server memory.

D. Use cookies to store cart items and rely on server to read them.

Solution

1. Step 1: Understand statelessness in API design

   Statelessness means server does not keep client state; all info must come with each request.

2. Step 2: Evaluate options for cart tracking

   Require the client to send the full cart data with each request. requires the client to send the full cart data with each request, fitting statelessness. Options A, B, and C rely on server or cookies storing state.

3. Final Answer:

   Require client to send full cart data with each request. -> Option B

4. Quick Check:

   Client sends all data = stateless API [OK]

Hint: Keep server stateless by sending all data from client every time [OK]

Common Mistakes:

• Using server sessions to store cart
• Assuming cookies make API stateless
• Relying on server memory for user data