Mocking external services in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Flask route when the external API is mocked?

Consider this Flask route that calls an external API to get user data. The external API is mocked to return a fixed response.

import requests
from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/user/')
def get_user(user_id):
    response = requests.get(f'https://api.example.com/users/{user_id}')
    data = response.json()
    return jsonify({'name': data['name'], 'id': data['id']})

# Mock setup:
# requests.get is mocked to always return a response with json() = {'id': 42, 'name': 'Alice'}

What will be the JSON output when accessing /user/10?

A {"name": "Unknown", "id": 10}

B {"name": "Alice", "id": 42}

C {"name": "Alice", "id": 10}

D 500 Internal Server Error

💡 Hint

Remember the mock always returns the same data regardless of the user_id.

The mocked requests.get always returns a response whose json() method returns {'id': 42, 'name': 'Alice'}. So the route returns this data wrapped in JSON, ignoring the URL user_id.

🔧 Debug

intermediate

Why does this Flask test fail when mocking an external service?

In this Flask test, the external API call is mocked but the test fails with a TypeError.

import pytest
from unittest.mock import patch

@patch('requests.get')
def test_user(mock_get, client):
    mock_get.return_value.json = {'id': 1, 'name': 'Bob'}
    response = client.get('/user/1')
    assert response.json == {'id': 1, 'name': 'Bob'}

What is the cause of the error?

A mock_get.return_value.json should be a callable, not a dict

B The patch decorator is applied to the wrong function

C The Flask client does not support .json attribute on response

D The test is missing a Flask app context

💡 Hint

Check what response.json expects to be in the mock.

The json attribute of the mocked response must be a callable method returning the dict, not the dict itself. Assigning a dict directly causes a TypeError when called.

📝 Syntax

advanced

Which option correctly mocks a Flask external API call using unittest.mock?

You want to mock requests.get in a Flask test to return a JSON response {'status': 'ok'}. Which code snippet is correct?

A

with patch('requests.get') as mock_get:
    mock_get.return_value.json = lambda: {'status': 'ok'}

B

with patch('requests.get') as mock_get:
    mock_get.return_value.json = {'status': 'ok'}

C

with patch('requests.get') as mock_get:
    mock_get.return_value = {'status': 'ok'}

D

with patch('requests.get') as mock_get:
    mock_get.json.return_value = {'status': 'ok'}

💡 Hint

The mocked json must be a callable method returning the dict.

Option A correctly sets mock_get.return_value.json to a lambda returning the dict. Option A tries to set json on the mock_get itself, which is wrong. Option A sets the return_value to a dict, not a mock response. Option A sets json to a dict, not a callable.

❓ state_output

advanced

What is the value of variable 'result' after mocking an external API in Flask?

Given this Flask function and test snippet:

def fetch_data():
    import requests
    response = requests.get('https://api.example.com/data')
    return response.json()['value']

# Test with mock:
from unittest.mock import patch

with patch('requests.get') as mock_get:
    mock_get.return_value.json = lambda: {'value': 123}
    result = fetch_data()

What is the value of result?

A Raises a TypeError

B {'value': 123}

C None

D 123

💡 Hint

Look at what fetch_data returns from the mocked JSON.

The mocked json() returns {'value': 123}. The function returns the value of the 'value' key, which is 123.

🧠 Conceptual

expert

Which option best explains why mocking external services is important in Flask testing?

Why do developers mock external API calls when testing Flask applications?

A To avoid writing any test code and rely on production data

B To increase the complexity of tests by adding real API calls

C To isolate tests from network issues and ensure consistent, fast, and reliable test results

D To make tests slower and dependent on external service uptime

💡 Hint

Think about test speed and reliability.

Mocking external services isolates tests from network failures and variability, making tests faster and more reliable. It avoids dependency on external service availability.

Practice

1. What is the main reason to mock external services in Flask testing?

easy

A. To change the Flask app configuration permanently

B. To speed up the Flask server in production

C. To add more routes to the Flask app

D. To avoid making real network calls during tests

Solution

1. Step 1: Understand the purpose of mocking

   Mocking replaces real external calls with fake ones to avoid delays and failures during tests.

2. Step 2: Identify the benefit in Flask testing

   This avoids real network calls, making tests faster and more reliable.

3. Final Answer:

   To avoid making real network calls during tests -> Option D

4. Quick Check:

   Mocking = Avoid real network calls [OK]

Hint: Mock to skip real network calls in tests [OK]

Common Mistakes:

• Thinking mocking speeds up production
• Confusing mocking with adding routes
• Believing mocking changes app config permanently

2. Which of the following is the correct way to patch an external function requests.get in a Flask test using unittest.mock?

easy

A. with patch('requests.get') as mock_get:

B. with patch(requests.get) as mock_get:

C. with patch('requests->get') as mock_get:

D. with patch('requests_get') as mock_get:

Solution

1. Step 1: Understand patch syntax

   Patch requires the full path as a string, e.g., 'requests.get'.

2. Step 2: Identify correct string format

   with patch('requests.get') as mock_get: uses the correct string 'requests.get'. Others use invalid syntax or missing quotes.

3. Final Answer:

   with patch('requests.get') as mock_get: -> Option A

4. Quick Check:

   Patch needs string path = with patch('requests.get') as mock_get: [OK]

Hint: Patch uses string path like 'module.function' [OK]

Common Mistakes:

• Passing function object instead of string
• Using wrong string format with arrows
• Missing quotes around patch target

3. Given this Flask test code snippet, what will be printed?

from unittest.mock import patch
import requests

def fetch_data():
    response = requests.get('http://example.com')
    return response.status_code

with patch('requests.get') as mock_get:
    mock_get.return_value.status_code = 404
    print(fetch_data())

medium

A. None

B. 200

C. 404

D. Raises an error

Solution

1. Step 1: Understand patch effect on requests.get

   The patch replaces requests.get with a mock whose return_value.status_code is set to 404.

2. Step 2: Trace fetch_data call inside patch

   fetch_data calls requests.get, which returns the mock with status_code 404, so fetch_data returns 404.

3. Final Answer:

   404 -> Option C

4. Quick Check:

   Mocked status_code = 404 [OK]

Hint: Mock return_value sets fake response attributes [OK]

Common Mistakes:

• Expecting real HTTP 200 response
• Confusing mock object with None
• Thinking patch causes error

4. What is wrong with this Flask test code that tries to mock requests.post?

from unittest.mock import patch
import requests

def send_data():
    response = requests.post('http://example.com', data={'key': 'value'})
    return response.ok

with patch('requests.post') as mock_post:
    mock_post.ok = True
    print(send_data())

medium

A. mock_post.ok should be set on return_value, not mock_post

B. patch target should be 'requests.get' not 'requests.post'

C. send_data should use requests.get instead of post

D. mock_post.ok is correct and code works fine

Solution

1. Step 1: Identify mock object usage

   mock_post is the mock for requests.post function, its return_value simulates the response object.

2. Step 2: Correct attribute assignment

   Setting mock_post.ok sets attribute on the function mock, not the response. It should be mock_post.return_value.ok = True.

3. Final Answer:

   mock_post.ok should be set on return_value, not mock_post -> Option A

4. Quick Check:

   Mock response attributes go on return_value [OK]

Hint: Set mock response attributes on return_value [OK]

Common Mistakes:

• Setting attributes on mock function instead of return_value
• Confusing post with get method
• Assuming code works without fixing mock

5. You want to test a Flask route that calls an external API and returns JSON data. Which approach correctly mocks the external API call and returns a custom JSON response {"success": true} during the test?

hard

A. Use patch on the Flask route function and return {"success": true} directly

B. Use patch on the external call, set return_value.json.return_value = {"success": true}

C. Call the real external API and check if it returns {"success": true}

D. Mock the Flask app config to include {"success": true}

Solution

1. Step 1: Identify what to mock

   The external API call (e.g., requests.get) should be mocked to avoid real network calls.

2. Step 2: Set mock return JSON data

   Set the mock's return_value.json.return_value to the desired JSON dict to simulate API response.

3. Final Answer:

   Use patch on the external call, set return_value.json.return_value = {"success": true} -> Option B

4. Quick Check:

   Mock external call's json() method = Use patch on the external call, set return_value.json.return_value = {"success": true} [OK]

Hint: Mock return_value.json.return_value for JSON responses [OK]

Common Mistakes:

• Mocking Flask route instead of external call
• Calling real API in tests
• Changing app config instead of mocking