Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
modul:m450:learningunits:lu04:monkeypatch [2024/11/12 07:30] – msutermodul:m450:learningunits:lu04:monkeypatch [2026/11/17 08:03] (aktuell) – Klassenbeispiel korrigiert (Patch wirkt jetzt tatsächlich), Fehlerfall simulieren, Stolperfalle Import, Lernziele, Kontrollfragen, Fusszeile und Kompetenz-Tags admin
Zeile 1: Zeile 1:
 ====== LU04b - Funktionen und Klassen simulieren ====== ====== LU04b - Funktionen und Klassen simulieren ======
-<WRAP center round tip 60%> +<WRAP center round info 80%> 
-Mit ''monkeypatch'' können Funktionen und Klassen während des Tests simuliert werden. +**Auf einen Blick**\\ 
-Dadurch können einzelne Programmteile isoliert getestet werden.+Die getestete Funktion ruft oft andere Funktionen oder Klassen auf, zum Beispiel für den Zugriff auf eine Datenbank. 
 +Mit ''monkeypatch'' ersetzen wir diese Abhängigkeiten während des Tests durch einfache Platzhalter, die feste Werte liefern. 
 +So testen wir die Funktion **isoliert**: schnell, wiederholbar und unabhängig von Datenbank, Netzwerk oder unfertigem Code.
 </WRAP> </WRAP>
  
-Ein Unittest soll eine einzelne Funktion oder sogar nur Teile einer Funktion testen. +===== Lernziele ===== 
-Die zu testende Funktion wird aber in der Regel Objekte verarbeiten und weitere Funktionen/Methoden aufrufen. +Sie können 
-Funktionen und Klassen werden bei Unittests simuliert (oder "gemockt"), um bestimmte Abhängigkeiten zu isolieren und das Testen einzelner Komponenten zu ermöglichen, ohne dass externe Systeme oder komplexe Abläufe involviert sind. Hier sind die Hauptgründe, warum Mocking beim Testen hilfreich ist:+  * erklären, warum Abhängigkeiten in Unit Tests simuliert werden, 
 +  * eine Funktion mit ''monkeypatch.setattr'' durch einen Platzhalter ersetzen, 
 +  * eine Klasse durch eine simulierte Klasse ersetzen, 
 +  * Fehlerzustände wie einen Verbindungsabbruch gezielt simulieren.
  
-==== Isolation der Testobjekte ==== +===== Warum simulieren? ===== 
-Mocking hilft, sich nur auf die zu testende Funktion oder Klasse zu konzentrieren, ohne dass Abhängigkeiten zu anderen Modulen oder Komponenten den Test beeinflussen. So können wir sicherstellen, dass der Test nur das Verhalten der spezifischen Komponente überprüft und nicht durch externe Faktoren verzerrt wird. +^ Grund                          ^ Erklärung                                                                                  ^ 
- +| **Isolation**                  | Der Test prüft nur die eine Funktion. Ein Fehler in einer anderen Komponente verfälscht das Ergebnis nicht. | 
-==== Vermeidung externer Abhängigkeiten ==== +| **Keine externen Systeme**     | Datenbanken, APIs oder Dateien sind im Test oft nicht verfügbar, langsam oder liefern wechselnde Daten. | 
-In vielen Anwendungen greifen Funktionen und Klassen auf externe Ressourcen zu, wie Datenbanken, APIs, Dateisysteme oder Netzwerke. Diese Ressourcen sind oft schwer zugänglich, langsam oder unzuverlässig. Durch Mocking werden solche Abhängigkeiten ersetzt, sodass Tests schnell, zuverlässig und unabhängig von der Verfügbarkeit externer Ressourcen sind. +| **Kontrolle**                  | Wir bestimmen genau, welche Daten zurückkommen, und können Fehler wie einen Netzwerkausfall auslösen. | 
- +| **Geschwindigkeit**            | Ein Platzhalter antwortet sofort. Auch grosse Testsuiten bleiben schnell.                  | 
-==== Kontrolle über Rückgabewerte und Fehlerzustände ==== +| **Frühes Testen**              | Wir können eine Funktion testen, bevor die aufgerufene Klasse fertig programmiert ist.     |
-Mocks ermöglichen es, gezielt verschiedene Rückgabewerte oder Fehler zu simulieren, um zu überprüfen, wie die getestete Komponente darauf reagiert. So lassen sich Szenarien testen, die in der realen Umgebung schwer reproduzierbar wären, wie Netzwerkfehler oder spezifische Ausnahmefälle. +
- +
-==== Verbesserte Performance ==== +
-Da Mocks die tatsächlichen Ausführungen komplexer Funktionen oder Klassen ersetzen, laufen Tests oft schneller und benötigen weniger Ressourcen. Besonders bei großen Test-Suites führt dies zu einer deutlichen Zeitersparnis. +
- +
-Insgesamt macht Mocking Unittests flexibler, effizienter und zuverlässiger, was die Qualität und Wartbarkeit des Codes verbessert.+
  
 +Solche Platzhalter heissen je nach Verwendung **Stub** (liefert feste Werte, siehe [[modul:m450:learningunits:lu02:teststrategie|LU02a]]) oder **Mock** (prüft zusätzlich, wie er aufgerufen wurde, siehe [[modul:m450:learningunits:lu11:mock|LU11b]]). Im Alltag sagt man oft für beides «mocken».
  
 ===== Funktionen simulieren ===== ===== Funktionen simulieren =====
-Nehmen wir einmal an, wir möchten eine Funktion ''process_data'' testen. +Die Funktion ''process_data'' holt Daten mit ''get_data_from_database'' und verdoppelt sie. Wir wollen nur die Verarbeitung testen, nicht den Datenbankzugriff.
-Diese Funktion ruft eine andere Funktion ''get_data_from_database'' auf, welche die Daten liest.. +
-Für unsere Unittests der Funktion ''process_data'' wollen wir die Funktion ''get_data_from_database'' simulieren.+
  
 <code python> <code python>
Zeile 33: Zeile 31:
  
 def get_data_from_database(): def get_data_from_database():
-    """ +    # Hier stünde normalerweise eine Datenbankabfrage. 
-    Diese Funktion würde normalerweise eine Datenbank abfragen und Daten zurückgeben. +    raise NotImplementedError('Diese Funktion greift normalerweise auf eine Datenbank zu.') 
-    Wir simulieren diese Funktion im Test. +
-    """ +
-    # Hier könnte normalerweise eine Datenbankabfrage stehen +
-    raise NotImplementedError("Diese Funktion greift normalerweise auf eine Datenbank zu.")+
  
 def process_data(): def process_data():
-    """ 
-    Diese Funktion ruft Daten von der Datenbank ab und verarbeitet sie. 
-    """ 
     data = get_data_from_database()     data = get_data_from_database()
-    # Verarbeiten wir die Daten (hier nur ein einfaches Beispiel) 
     return [item * 2 for item in data]     return [item * 2 for item in data]
 </code> </code>
  
 <code python> <code python>
 +# test_my_module.py
 import pytest import pytest
 from my_module import process_data from my_module import process_data
  
-# Fixture zum Simulieren der Datenbankabfrage-Funktion+
 @pytest.fixture @pytest.fixture
 def mock_get_data_from_database(monkeypatch): def mock_get_data_from_database(monkeypatch):
-    """ 
-    Simuliert die Funktion `get_data_from_database`, um feste Testdaten zurückzugeben. 
-    """ 
     def mock_data():     def mock_data():
-        return [1, 2, 3]  # Beispielhafte Testdaten, die anstelle echter Daten zurückgegeben werden+        return [1, 2, 3] 
 + 
 +    monkeypatch.setattr('my_module.get_data_from_database', mock_data)
  
-    # Ersetzen der echten Funktion durch die simulierte Version 
-    monkeypatch.setattr("my_module.get_data_from_database", mock_data) 
  
 def test_process_data(mock_get_data_from_database): def test_process_data(mock_get_data_from_database):
-    """ 
-    Testet die Funktion `process_data`, indem die Datenbankabfrage-Funktion simuliert wird. 
-    """ 
     result = process_data()     result = process_data()
-    assert result == [2, 4, 6], "Die Daten sollten verdoppelt werden."+    assert result == [2, 4, 6], 'Die Daten sollten verdoppelt werden.'
 </code> </code>
  
-Mit der Zeile ''monkeypatch.setattr("my_module.get_data_from_database", mock_data)'' teilen wir Pytest mit, +  * ''monkeypatch.setattr('my_module.get_data_from_database', mock_data)'' ersetzt die Funktion im Modul ''my_module'' durch ''mock_data''. 
-dass anstelle von ''get_data_from_database'' die Funktion ''mock_data'' aufgerufen wird.+  * Ruft ''process_data'' nun ''get_data_from_database()'' auf, wird in Wirklichkeit ''mock_data()'' ausgeführt. 
 +  * Nach dem Test stellt PyTest die Originalfunktion automatisch wieder her. 
 + 
 +<WRAP center round important 80%> 
 +**Stolperfalle:** Ersetzen Sie die Funktion in dem Modul, in dem sie **aufgerufen** wird. Importiert ein Modul ''report.py'' die Funktion mit ''from my_module import get_data_from_database'', müssen Sie ''%%'report.get_data_from_database'%%'' patchen und nicht ''%%'my_module.get_data_from_database'%%''. 
 +</WRAP>
  
 ===== Klassen simulieren ===== ===== Klassen simulieren =====
-Auch ganze Klassen mit ihren Attributen und Methoden lassen sich in Unittests simulieren. +Die Funktion ''get_processed_data'' erzeugt selbst ein ''DatabaseClient''-Objekt und holt damit Daten.
-Einerseits lässt sich dadurch eine Funktion testen, bevor die Klasse überhaupt realisiert wurde. +
-Andererseits isolieren wir die zu testende Funktion von allfälligen Fehlern in der Umsetzung der Klasse.+
  
 <code python> <code python>
Zeile 85: Zeile 74:
  
 class DatabaseClient: class DatabaseClient:
-    """ 
-    Klasse zum Verbinden mit einer Datenbank und Abrufen von Daten. 
-    """ 
     def fetch_data(self):     def fetch_data(self):
-        # In einer echten Anwendung würde hier eine Datenbankabfrage stehen. +        # In einer echten Anwendung stünde hier eine Datenbankabfrage. 
-        raise NotImplementedError("Verbindung zur echten Datenbank.")+        raise NotImplementedError('Verbindung zur echten Datenbank.')
  
-def get_processed_data(db_client): + 
-    """ +def get_processed_data(): 
-    Funktion, die Daten vom DatabaseClient abruft und verarbeitet. +    db_client = DatabaseClient()
-    """+
     data = db_client.fetch_data()     data = db_client.fetch_data()
-    # Beispielhafte Verarbeitung: jedes Element um 1 erhöhen 
     return [item + 1 for item in data]     return [item + 1 for item in data]
- 
 </code> </code>
 +
 +Im Test ersetzen wir die ganze Klasse ''DatabaseClient'' durch eine eigene Klasse mit derselben Methode:
  
 <code python> <code python>
 # test_database_module.py # test_database_module.py
- 
 import pytest import pytest
 from database_module import get_processed_data from database_module import get_processed_data
  
-# Fixture zum Simulieren der Klasse DatabaseClient+ 
 +class MockDatabaseClient: 
 +    def fetch_data(self): 
 +        return [10, 20, 30] 
 + 
 @pytest.fixture @pytest.fixture
 def mock_db_client(monkeypatch): def mock_db_client(monkeypatch):
-    """ +    monkeypatch.setattr('database_module.DatabaseClient', MockDatabaseClient)
-    Simuliert die DatabaseClient-Klasse, um feste Testdaten zurückzugeben. +
-    """ +
-    # Simulierte Klasse +
-    class MockDatabaseClient: +
-        def fetch_data(self): +
-            return [10, 20, 30]  # Beispielhafte Testdaten+
  
-    # Ersetzen der echten DatabaseClient-Klasse durch die simulierte Version 
-    monkeypatch.setattr("database_module.DatabaseClient", MockDatabaseClient) 
-     
-    # Instanz der simulierten Klasse zurückgeben 
-    return MockDatabaseClient() 
  
 def test_get_processed_data(mock_db_client): def test_get_processed_data(mock_db_client):
-    """ +    result = get_processed_data() 
-    Testet die Funktion `get_processed_data`, indem die DatabaseClient-Klasse simuliert wird. +    assert result == [11, 21, 31], 'Die Daten sollten um 1 erhöht werden.'
-    """ +
-    result = get_processed_data(mock_db_client) +
-    assert result == [11, 21, 31], "Die Daten sollten um 1 erhöht werden."+
 </code> </code>
  
-==== Erläuterung ==== +Weil ''get_processed_data'' jetzt ein ''MockDatabaseClient''-Objekt erzeugt, liefert ''fetch_data()'' die Testdaten ''[10, 20, 30]''. Das Ergebnis ist ''[11, 21, 31]''. 
-** Fixture mock_db_client: **+ 
 +<WRAP center round tip 80%> 
 +Erhält eine Funktion das Objekt als **Parameter**, zum Beispiel ''get_processed_data(db_client)'', brauchen Sie ''monkeypatch'' gar nicht. Sie übergeben im Test einfach ein ''MockDatabaseClient()''. Code, der seine Abhängigkeiten als Parameter erhält, ist deshalb leichter zu testen. 
 +</WRAP> 
 + 
 +===== Fehler simulieren ===== 
 +Wie reagiert das Programm, wenn die Datenbank nicht erreichbar ist? In der Realität lässt sich das schlecht testen, mit ''monkeypatch'' ist es einfach. Hier ersetzen wir nur eine einzelne Methode der Klasse: 
 + 
 +<code python> 
 +import pytest 
 +import database_module 
 +from database_module import get_processed_data 
 + 
 + 
 +def test_db_error(monkeypatch): 
 +    def broken_fetch(self): 
 +        raise ConnectionError('Datenbank nicht erreichbar') 
 + 
 +    monkeypatch.setattr(database_module.DatabaseClient, 'fetch_data', broken_fetch) 
 +    with pytest.raises(ConnectionError): 
 +        get_processed_data() 
 +</code> 
 + 
 +===== Weitere Möglichkeiten von monkeypatch ===== 
 +^ Methode                                        ^ Zweck                                       ^ 
 +| ''monkeypatch.setattr(ziel, wert)''           | Funktion, Methode, Klasse oder Attribut ersetzen | 
 +| ''monkeypatch.setitem(dictionary, key, wert)''| Eintrag in einem Dictionary setzen          | 
 +| ''monkeypatch.setenv('NAME', 'wert')''        | Umgebungsvariable setzen                    | 
 +| ''monkeypatch.delenv('NAME')''                | Umgebungsvariable löschen                   | 
 + 
 +===== Kontrollfragen ===== 
 +  - Nennen Sie drei Gründe, weshalb man in Unit Tests eine Datenbankabfrage simuliert. 
 +  - Was passiert nach dem Test mit der Funktion, die Sie mit ''monkeypatch.setattr'' ersetzt haben? 
 +  - Das Modul ''shop.py'' enthält ''from prices import get_price''. Welchen Namen geben Sie bei ''monkeypatch.setattr'' an, um ''get_price'' für ''shop.py'' zu ersetzen? 
 +  - Wie testen Sie, dass Ihr Programm bei einem Netzwerkfehler eine verständliche Meldung ausgibt?
  
-Diese Fixture erstellt eine simulierte Version der ''DatabaseClient''-Klasse, die eine Methode ''fetch_data()'' bereitstellt, welche die Beispiel-Daten [10, 20, 30] zurückgibt.  +===== Weiterführende Links ===== 
-Mit ''monkeypatch.setattr'' ersetzen wir die echte DatabaseClient-Klasse in ''database_module'' durch die simulierte MockDatabaseClient-Klasse. Die Fixture gibt eine Instanz von ''MockDatabaseClient'' zurück, die im Test verwendet wird.+  * [[https://docs.pytest.org/en/stable/how-to/monkeypatch.html|PyTest: How to monkeypatch/mock modules and environments]]
  
-** Test test_get_processed_data: **+---- 
 +{{tag>M450-LU04 M450-C1A M450-C1B}} 
 +[[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] Marcel Suter
  
-Der Test nutzt die Fixture ''mock_db_client'', um ''get_processed_data'' zu testen.  
-Da ''get_processed_data'' nun auf die simulierten Daten [10, 20, 30] zugreift, sollte das Ergebnis [11, 21, 31] sein (jedes Element um 1 erhöht). Der Test überprüft dies mit einer ''assert''-Anweisung. 
  • modul/m450/learningunits/lu04/monkeypatch.txt
  • Zuletzt geändert: 2026/11/17 08:03
  • von admin