Idempotency keys for safe retries in Rest API - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output when retrying a POST request with the same idempotency key?

Consider a REST API that uses idempotency keys to prevent duplicate resource creation. The client sends a POST request with an idempotency key header. The server stores the response for that key.

What will the server return if the client retries the same POST request with the same idempotency key?

Rest API

POST /orders HTTP/1.1
Idempotency-Key: abc123
{
  "item": "book",
  "quantity": 1
}

# Retry with the same Idempotency-Key: abc123

A The server ignores the idempotency key and processes the request normally.

B The server creates a new order again and returns a new order ID.

C The server returns an error indicating the idempotency key is already used.

D The server returns the original response for the first request without creating a new order.

💡 Hint

Think about why idempotency keys are used in APIs.

Idempotency keys ensure that retrying the same request does not create duplicate resources. The server returns the original response for the same key.

🧠 Conceptual

intermediate

Why are idempotency keys important in REST APIs?

Which of the following best explains the main purpose of idempotency keys in REST APIs?

A To allow safe retries of requests without creating duplicate effects.

B To encrypt the request payload for security.

C To speed up the server response time by caching.

D To authenticate the client making the request.

💡 Hint

Think about what happens when a client retries a request due to network issues.

Idempotency keys let clients retry requests safely by ensuring the server processes the request only once, avoiding duplicate side effects.

🔧 Debug

advanced

Identify the bug in this idempotency key handling code snippet

Review the following pseudocode for handling POST requests with idempotency keys. What is the bug?

Rest API

def handle_post(request):
    key = request.headers.get('Idempotency-Key')
    if key in cache:
        return cache[key]
    response = process_request(request)
    # Missing cache storage here
    return response

A The code does not check if the idempotency key is missing.

B The response is not stored in the cache after processing the request.

C The cache lookup should happen after processing the request.

D The code should delete the key from cache after returning the response.

💡 Hint

Think about what happens on the second request with the same key.

The code checks the cache but never stores the response after processing, so retries won't return the cached response.

📝 Syntax

advanced

Which option correctly implements idempotency key storage in Python?

Choose the code snippet that correctly stores and returns a cached response for an idempotency key.

Rest API

cache = {}

def handle_request(request):
    key = request.headers.get('Idempotency-Key')
    if key in cache:
        return cache[key]
    response = process(request)
    # Store response here
    return response

A

cache[key] <- response
return response

B

cache[key] == response
return response

C

cache[key] = response
return response

D

cache.add(key, response)
return response

💡 Hint

Remember how to assign values to dictionary keys in Python.

Option C correctly assigns the response to the dictionary key. Other options use invalid syntax or methods.

🚀 Application

expert

How many unique responses are stored after these requests with idempotency keys?

A client sends these POST requests to the server with idempotency keys:

1. POST with key 'x1'
2. POST with key 'x2'
3. POST with key 'x1' again (retry)
4. POST with key 'x3'
5. POST with key 'x2' again (retry)

Assuming the server correctly caches responses by idempotency key, how many unique responses are stored in the cache after these requests?

A 3

B 5

C 2

D 4

💡 Hint

Count unique keys used in the requests.

There are three unique keys: 'x1', 'x2', and 'x3'. Retries do not add new entries.