Testing with external services in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the requests library for testing external services.

PyTest

import [1]

Drag options to blanks, or click blank then click option'

Arequests

Bpytest

Cunittest

Djson

Attempts:

3 left

💡 Hint

Common Mistakes

Importing pytest instead of requests

Importing unittest which is for unit tests, not HTTP calls

The requests library is used to make HTTP calls to external services in tests.

2fill in blank

medium

Complete the code to mock the external HTTP GET request using pytest and requests.

PyTest

def test_api_call(mocker):
    mock_get = mocker.patch('requests.[1]')
    mock_get.return_value.status_code = 200
    response = requests.get('http://example.com')
    assert response.status_code == 200

Drag options to blanks, or click blank then click option'

Aget

Bdelete

Cput

Dpost

Attempts:

3 left

💡 Hint

Common Mistakes

Patching the wrong HTTP method like post or put

Not patching the requests method at all

The get method is patched to mock the HTTP GET request.

3fill in blank

hard

Fix the error in the test by completing the assertion to check the mocked JSON response.

PyTest

def test_api_json_response(mocker):
    mock_get = mocker.patch('requests.get')
    mock_get.return_value.status_code = 200
    mock_get.return_value.json = lambda: {'key': 'value'}
    response = requests.get('http://example.com')
    assert response.json() [1] {'key': 'value'}

Drag options to blanks, or click blank then click option'

Ain

B!=

Cis

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'is' which checks identity, not equality

Using '!=' which checks for inequality

The assertion should check equality with == to verify the JSON content.

4fill in blank

hard

Fill both blanks to create a pytest fixture that mocks requests.post and returns a 201 status code.

PyTest

@pytest.fixture
def mock_post(mocker):
    mock = mocker.patch('requests.[1]')
    mock.return_value.status_code = [2]
    return mock

Drag options to blanks, or click blank then click option'

Apost

Bget

Cput

D201

Attempts:

3 left

💡 Hint

Common Mistakes

Patching the wrong HTTP method

Using incorrect status code like 200 instead of 201

The fixture patches requests.post and sets the status code to 201 (Created).

5fill in blank

hard

Fill all three blanks to write a test that uses the mock_post fixture and asserts the response status code is 201.

PyTest

def test_create_resource(mock_post):
    response = requests.[1]('http://example.com/resource')
    assert response.[2] == [3]

Drag options to blanks, or click blank then click option'

Apost

Bstatus_code

C201

Dget

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'get' instead of 'post' for creation

Checking wrong attribute like 'json' instead of 'status_code'

Expecting wrong status code like 200

The test calls requests.post, checks status_code, and expects 201.

Practice

1. What is the main reason to use mocking when testing with external services in pytest?

easy

A. To avoid calling the real external service and make tests faster

B. To increase the number of real API calls during testing

C. To make tests dependent on internet speed

D. To test the external service itself

Solution

1. Step 1: Understand the role of mocking in tests

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

2. Step 2: Identify the benefit of mocking external services

   Mocking makes tests faster and more reliable by not depending on real services.

3. Final Answer:

   To avoid calling the real external service and make tests faster -> Option A

4. Quick Check:

   Mocking speeds up tests by faking external calls [OK]

Hint: Mock external calls to speed tests and avoid failures [OK]

Common Mistakes:

• Thinking mocking increases real API calls
• Believing tests should depend on internet speed
• Confusing testing external service with testing your code

2. Which of the following is the correct way to mock a function get_data from module external_api using pytest's patch decorator?

easy

A. @patch('external_api.get_data')

B. @patch('get_data.external_api')

C. @patch('external_api->get_data')

D. @patch('external_api.getData')

Solution

1. Step 1: Recall correct patch syntax

   The patch decorator requires the full import path as a string: 'module.function'.

2. Step 2: Match the correct option

   @patch('external_api.get_data') uses 'external_api.get_data' which is the correct format and case-sensitive.

3. Final Answer:

   @patch('external_api.get_data') -> Option A

4. Quick Check:

   patch('module.function') syntax is correct [OK]

Hint: Use 'module.function' string in patch decorator [OK]

Common Mistakes:

• Swapping module and function order
• Using wrong separators like '->'
• Incorrect function name casing

3. Given the following pytest test code, what will be the output when running the test?

from unittest.mock import patch
import requests

def fetch_status():
    response = requests.get('https://api.example.com/data')
    return response.status_code

@patch('requests.get')
def test_fetch_status(mock_get):
    mock_get.return_value.status_code = 200
    assert fetch_status() == 200
    print('Test passed')

medium

A. TypeError

B. AssertionError

C. Test passed

D. No output

Solution

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

   The patch replaces requests.get with a mock that returns an object with status_code 200.

2. Step 2: Check assertion and print statement

   fetch_status() returns 200, matching the assertion, so 'Test passed' is printed.

3. Final Answer:

   Test passed -> Option C

4. Quick Check:

   Mocked return_value.status_code = 200 makes test pass [OK]

Hint: Mock return_value to control function output [OK]

Common Mistakes:

• Forgetting to set return_value.status_code
• Expecting real HTTP call instead of mock
• Missing print output due to assertion failure

4. Identify the error in the following pytest test that mocks an external service call:

from unittest.mock import patch
import myservice

@patch('myservice.call_api')
def test_api(mock_call):
    mock_call.return_value = {'status': 'ok'}
    result = myservice.call_api()
    assert result.status == 'ok'

medium

A. The patch decorator is missing parentheses

B. The assertion should use result['status'] instead of result.status

C. mock_call.return_value should be a string, not a dict

D. The test function is missing a return statement

Solution

1. Step 1: Analyze the mocked return value type

   The mock returns a dictionary {'status': 'ok'}, so result is a dict.

2. Step 2: Check the assertion syntax

   Accessing dict keys requires bracket notation, not dot notation; result.status causes AttributeError.

3. Final Answer:

   The assertion should use result['status'] instead of result.status -> Option B

4. Quick Check:

   Dict keys need brackets, not dot notation [OK]

Hint: Use brackets for dict keys in assertions [OK]

Common Mistakes:

• Using dot notation on dicts
• Forgetting parentheses in patch decorator (not here)
• Expecting return_value must be string always

5. You want to test a function process_data() that calls an external API fetch_data(). The API sometimes returns null. How should you mock fetch_data in pytest to test process_data handles null correctly?

hard

A. Do not mock fetch_data; test process_data only with real data

B. Call the real fetch_data to see if it returns null

C. Mock fetch_data to always raise an exception

D. Use patch to make fetch_data return null and assert process_data handles it

Solution

1. Step 1: Understand the need to test null handling

   Since fetch_data can return null, tests must simulate this to check process_data behavior.

2. Step 2: Use patch to mock fetch_data returning null

   Mocking fetch_data to return null allows controlled testing of process_data's handling of that case.

3. Final Answer:

   Use patch to make fetch_data return null and assert process_data handles it -> Option D

4. Quick Check:

   Mock null return to test edge case handling [OK]

Hint: Mock edge cases like null to test error handling [OK]

Common Mistakes:

• Calling real external API in tests
• Mocking only success cases, ignoring null
• Ignoring exceptions instead of testing them