Mocking an HTTP API

• Patch requests.get to return a fake response.
• Mock .json(), .status_code, and raise_for_status.
• Test error paths: timeouts, 404s, bad JSON.
• Meet the responses library for cleaner HTTP mocks.

# weather.py
import requests

def get_temp(city):
    resp = requests.get(f"https://api.example.com/weather/{city}", timeout=5)
    resp.raise_for_status()
    return resp.json()["temp"]

Patch requests.get, return a fake response

from unittest.mock import patch, Mock
from weather import get_temp

@patch("weather.requests.get")          # patch where it's USED
def test_get_temp(mock_get):
    fake = Mock()
    fake.json.return_value = {"temp": 31}
    fake.raise_for_status.return_value = None     # no error
    mock_get.return_value = fake

    assert get_temp("KL") == 31
    mock_get.assert_called_once_with(
        "https://api.example.com/weather/KL", timeout=5)

Simulate an HTTP error (404)

import requests, pytest
from unittest.mock import patch, Mock

@patch("weather.requests.get")
def test_404_raises(mock_get):
    fake = Mock()
    fake.raise_for_status.side_effect = requests.HTTPError("404")
    mock_get.return_value = fake
    with pytest.raises(requests.HTTPError):
        get_temp("Atlantis")

Simulate a network timeout

@patch("weather.requests.get")
def test_timeout(mock_get):
    mock_get.side_effect = requests.Timeout("too slow")
    with pytest.raises(requests.Timeout):
        get_temp("KL")

Simulate bad JSON

@patch("weather.requests.get")
def test_bad_json(mock_get):
    fake = Mock()
    fake.json.side_effect = ValueError("not json")
    mock_get.return_value = fake
    with pytest.raises(ValueError):
        get_temp("KL")

Cleaner: the responses library

# pip install responses
import responses, requests

@responses.activate
def test_with_responses():
    responses.add(responses.GET,
                  "https://api.example.com/weather/KL",
                  json={"temp": 31}, status=200)
    assert get_temp("KL") == 31

responses registers fake endpoints by URL — no Mock plumbing. It's the cleaner choice for code that makes many HTTP calls. (For httpx there's respx; same idea.)

# test_weather.py — every path, zero network
import requests, pytest
from unittest.mock import patch, Mock
from weather import get_temp

def _fake_response(json_data=None, error=None):
    fake = Mock()
    fake.raise_for_status.return_value = None
    if error:
        fake.raise_for_status.side_effect = error
    fake.json.return_value = json_data
    return fake

@patch("weather.requests.get")
def test_success(mock_get):
    mock_get.return_value = _fake_response({"temp": 28})
    assert get_temp("Penang") == 28

@patch("weather.requests.get")
def test_http_error(mock_get):
    mock_get.return_value = _fake_response(error=requests.HTTPError("500"))
    with pytest.raises(requests.HTTPError):
        get_temp("X")

@patch("weather.requests.get")
def test_timeout(mock_get):
    mock_get.side_effect = requests.Timeout()
    with pytest.raises(requests.Timeout):
        get_temp("X")

@patch("weather.requests.get")
def test_url_and_timeout_used(mock_get):
    mock_get.return_value = _fake_response({"temp": 30})
    get_temp("JB")
    mock_get.assert_called_once_with(
        "https://api.example.com/weather/JB", timeout=5)

$ pytest test_weather.py -v
test_success PASSED
test_http_error PASSED
test_timeout PASSED
test_url_and_timeout_used PASSED
4 passed in 0.02s     ← no internet needed

Read the diff

A helper _fake_response builds the mock response so each test stays short. We cover the happy path, an HTTP error, a timeout, and verify the URL + timeout were used correctly — all offline, instantly, deterministically. This is exactly how you'd test the Level-4 weather and trivia apps reliably.

Patch requests.get (where it's used) and return a fake response with .json() / .status_code / raise_for_status. Use side_effect for timeouts and HTTP errors. The responses library makes URL-based HTTP mocking cleaner. Now your Level-4 API apps are fully testable offline. Next: a mocking challenge.