Mocking external services in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Django test using mock?

Consider this Django test case that mocks an external API call. What will be the printed output when the test runs?

Django

from unittest.mock import patch
from django.test import TestCase

class ExternalService:
    def fetch_data(self):
        # Imagine this calls an external API
        return 'real data'

class MyTest(TestCase):
    @patch.object(ExternalService, 'fetch_data')
    def test_mocked_fetch(self, mock_fetch):
        mock_fetch.return_value = 'mocked data'
        service = ExternalService()
        result = service.fetch_data()
        print(result)
        self.assertEqual(result, 'mocked data')

A None

B real data

C mocked data

D Raises AttributeError

💡 Hint

Look at what the mock replaces and what return_value is set to.

The patch decorator replaces the fetch_data method with a mock that returns 'mocked data'. So calling fetch_data returns 'mocked data'.

📝 Syntax

intermediate

Which option correctly mocks a Django external service method?

You want to mock the method 'get_user_info' of the class 'UserService' located in 'myapp.services'. Which of these patch decorators is correct?

A @patch('myapp.services.UserService.get_user_info')

B @patch('UserService.get_user_info')

C @patch('myapp.UserService.get_user_info')

D @patch('services.UserService.get_user_info')

💡 Hint

The patch path must be the full import path to the method.

The patch decorator requires the full import path to the method to mock it correctly. 'myapp.services.UserService.get_user_info' is the correct full path.

🔧 Debug

advanced

Why does this mock not replace the external call in Django test?

Given this test code, why does the external API call still run instead of being mocked?

Django

from unittest.mock import patch
from django.test import TestCase

class ExternalAPI:
    def call(self):
        return 'real response'

class MyTest(TestCase):
    @patch('external_api.ExternalAPI.call')
    def test_api_call(self, mock_call):
        mock_call.return_value = 'mocked response'
        api = ExternalAPI()
        response = api.call()
        print(response)
        self.assertEqual(response, 'mocked response')

A The mock_call.return_value is set after the call, so it has no effect.

B The patch path is incorrect; it should match where ExternalAPI is imported in the test module.

C The ExternalAPI class is not patched, only the method, so the call runs real code.

D The test method is missing a call to mock_call.start() to activate the patch.

💡 Hint

Check where ExternalAPI is imported and how patch paths work.

Patch must target the exact location where the object is used. If ExternalAPI is imported differently in the test module, patching 'external_api.ExternalAPI.call' won't replace the method.

❓ state_output

advanced

What is the value of 'call_count' after this Django test runs?

In this test, how many times was the mocked method called?

Django

from unittest.mock import patch
from django.test import TestCase

class Service:
    def fetch(self):
        return 'data'

class MyTest(TestCase):
    @patch.object(Service, 'fetch')
    def test_calls(self, mock_fetch):
        mock_fetch.return_value = 'mocked'
        service = Service()
        service.fetch()
        service.fetch()
        count = mock_fetch.call_count
        print(count)
        self.assertEqual(count, 2)

A 2

B 1

C 0

D Raises AttributeError

💡 Hint

call_count tracks how many times the mock was called.

The mock replaces fetch, so each call increments call_count. Two calls mean call_count is 2.

🧠 Conceptual

expert

Which statement best describes mocking external services in Django tests?

Select the most accurate statement about mocking external services in Django tests.

A Mocking external services is unnecessary if the service is reliable and always available during tests.

B Mocking permanently changes the external service code so all future calls in the app use the mocked version.

C Mocking requires modifying the external service code to add special test hooks.

D Mocking replaces the external service call only within the test scope, preventing real network requests and allowing controlled responses.

💡 Hint

Think about the scope and purpose of mocking in tests.

Mocking temporarily replaces calls during tests to avoid real external calls and control test conditions. It does not change code permanently or require modifying external services.