Python Academy · Lektion

Mocking mit unittest.mock

Isolieren Sie die zu testenden Einheiten, indem Sie Abhängigkeiten mocken.

Mocking mit unittest.mock ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Mocking?

Mocks ersetzen echte Abhängigkeiten (Datenbanken, APIs, Dateisystem) durch kontrollierbare Fakes, damit Tests schnell, deterministisch und isoliert ausgeführt werden.

from unittest.mock import Mock

api = Mock()
api.get_user.return_value = {"id": 1, "name": "Alice"}

result = api.get_user(1)
print(result)  # {'id': 1, 'name': 'Alice'}

Mock und MagicMock

Mock ist die Basisklasse. MagicMock konfiguriert Magic- beziehungsweise Dunder-Methoden automatisch, sodass es beispielsweise als Iterator oder Context Manager verwendet werden kann.

from unittest.mock import MagicMock

m = MagicMock()
m.__len__.return_value = 5
print(len(m))  # 5

m.__iter__.return_value = iter([1, 2, 3])
for x in m:
    print(x)

patch als Decorator

Verwenden Sie @patch, um ein Objekt in einem Modul für die Dauer des Tests durch einen Mock zu ersetzen.

from unittest.mock import patch

def get_data():
    import requests
    return requests.get("https://api.example.com").json()

@patch("requests.get")
def test_get_data(mock_get):
    mock_get.return_value.json.return_value = {"key": "value"}
    result = get_data()
    assert result == {"key": "value"}

patch als Context Manager

Verwenden Sie patch() als Context Manager, um das Mocking auf einen kleineren Bereich zu begrenzen.

from unittest.mock import patch

def test_open():
    with patch("builtins.open", create=True) as mock_open:
        mock_open.return_value.__enter__.return_value.read.return_value = "data"
        with open("file.txt") as f:
            assert f.read() == "data"

patch.object

patch.object(target, attribute) ersetzt ein bestimmtes Attribut eines vorhandenen Objekts oder einer Klasse.

from unittest.mock import patch
import mymodule

def test_method():
    with patch.object(mymodule.MyClass, "fetch", return_value=42):
        obj = mymodule.MyClass()
        assert obj.fetch() == 42

Aufrufe überprüfen

Mocks protokollieren jeden Aufruf. Verwenden Sie assert_called_once_with, assert_called_with und call_count, um das Verhalten zu überprüfen.

from unittest.mock import Mock

send = Mock()
send("hello", to="alice")

send.assert_called_once_with("hello", to="alice")
print(send.call_count)  # 1

return_value und side_effect

Setzen Sie return_value, um zu bestimmen, was der Mock zurückgibt. Verwenden Sie side_effect, um Ausnahmen auszulösen oder bei aufeinanderfolgenden Aufrufen unterschiedliche Werte zurückzugeben.

from unittest.mock import Mock

m = Mock(side_effect=[1, 2, ValueError("done")])
print(m())  # 1
print(m())  # 2
m()         # raises ValueError

spec: Typsichere Mocks

Übergeben Sie spec=MyClass, um den Mock auf Attribute zu beschränken, die in der echten Klasse vorhanden sind.

from unittest.mock import Mock

class Calc:
    def add(self, a, b): return a + b

m = Mock(spec=Calc)
m.add(1, 2)         # OK
# m.subtract(1, 2)  # AttributeError: Mock does not have 'subtract'

patch.dict

Verwenden Sie patch.dict, um ein Dictionary vorübergehend zu ändern, beispielsweise Umgebungsvariablen oder Konfigurationen auf Modulebene.

from unittest.mock import patch
import os

def test_env():
    with patch.dict(os.environ, {"DEBUG": "true"}):
        assert os.environ["DEBUG"] == "true"
    assert "DEBUG" not in os.environ

Mocking in pytest mit pytest-mock

pytest-mock stellt ein mocker-Fixture bereit, das unittest.mock kapselt und nach jedem Test automatisch aufräumt.

# pip install pytest-mock

def test_service(mocker):
    mocker.patch("mymodule.requests.get", return_value=mocker.Mock(
        json=lambda: {"status": "ok"}
    ))
    from mymodule import call_api
    assert call_api()["status"] == "ok"

AsyncMock für Coroutinen

Verwenden Sie AsyncMock, um asynchrone Funktionen zu mocken, auf die gewartet wird.

from unittest.mock import AsyncMock, patch
import asyncio

async def fetch():
    import httpx
    async with httpx.AsyncClient() as c:
        r = await c.get("https://example.com")
        return r.json()

def test_fetch():
    with patch("httpx.AsyncClient.get", new_callable=AsyncMock) as m:
        m.return_value.json.return_value = {"ok": True}
        result = asyncio.run(fetch())
        assert result["ok"] is True

Kurztest

Welches Attribut setzen Sie bei einem Mock, um den Rückgabewert eines Aufrufs zu bestimmen?

Zusammenfassung

unittest.mock stellt Mock, MagicMock, patch und AsyncMock bereit. Verwenden Sie return_value und side_effect, um das Verhalten zu steuern, und Assertion-Methoden, um zu überprüfen, wie die Mocks aufgerufen wurden.

Häufig gestellte Fragen

Ist die Lektion „Mocking mit unittest.mock“ kostenlos?

Ja — der vollständige Text von „Mocking mit unittest.mock“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Mocking mit unittest.mock“?

Isolieren Sie die zu testenden Einheiten, indem Sie Abhängigkeiten mocken. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Mocking mit unittest.mock“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy