Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
modul:m450:learningunits:lu03:unittest [2024/10/02 10:08] – msutermodul:m450:learningunits:lu03:unittest [2026/11/17 07:56] (aktuell) – Neu gefasst im Stil von LU01/LU02: Lernziele, Isolation, AAA-Beispiel, Kontrollfragen, Kompetenz-Tags admin
Zeile 1: Zeile 1:
 ====== LU03a - Unit Tests ====== ====== LU03a - Unit Tests ======
-<WRAP center round info 60%> +<WRAP center round info 80%> 
-**Unit Tests** resp. **Komponententests** sind automatisierte Tests //kleiner// Codeeinheiten, die **isoliert** getestet werden und weisen Aspekte von White-Box und Black-Box Tests auf (siehe Theorie über Testverfahren).  +**Auf einen Blick**\\ 
-Im Wesentlichen ist ein Unit Test ein Programm, das die öffentlichen Methoden einer Klasse aufruft und überprüft, ob die Ergebnisse den Erwartungen entspricht.+Ein **Unit Test** (Komponententest) prüft eine kleine Codeeinheit, meist eine Funktion oder eine Methode, **isoliert** vom Rest des Programms. 
 +Er ist selbst ein kleines Programm: Er ruft die Einheit mit festgelegten Daten auf und vergleicht das Ergebnis automatisch mit dem erwarteten Wert.
 </WRAP> </WRAP>
  
-===== Vorteile von Unit Tests =====+===== Lernziele ===== 
 +Sie können 
 +  * erklären, was ein Unit Test ist und was ihn von einem Integrationstest unterscheidet, 
 +  * die Vorteile automatisierter gegenüber manueller Tests nennen, 
 +  * einen Unit Test nach dem Muster Arrange – Act – Assert aufbauen, 
 +  * die FIRST-Prinzipien erklären und an einem Test überprüfen.
  
-Wenn Sie Ihre Komponententests richtig geschrieben haben, bringen sie mehrere Vorteile bezgl. der Wartung des Codes:+===== Was ist eine «Unit»? ===== 
 +Eine Unit ist der kleinste Baustein, den man sinnvoll für sich allein testen kann. In Python ist das meistens 
 +  * eine **Funktion**, zum Beispiel ''factorial(number)'', 
 +  * oder eine **Methode** einer Klasse, zum Beispiel ''account.deposit(amount)''.
  
-  * **Dank Komponententests werden Fehler bereits während der Entwicklung gefunden:** Wenn Sie einen Codeabschnitt umgestalten oder erweitern und Ihre früheren Tests fehlschlagen, haben Sie das Verhalten dieser Methode geändert, was auf einen Fehler hinweisen könnte. +Ein Unit Test kennt die Schnittstelle der Unit: Name, Parameter, Rückgabewert und mögliche Exceptions. Was im Innern passiert, spielt für das Ergebnis keine Rolle.
-  * Der Korrekturaufwand für neu gefundenen Fehler ist erheblich **geringer**, als wenn diese erst im laufenden Betrieb gefunden werden. +
-  * Mit anderen Worten, Komponententests schützen Ihren Code vor **Regression** (d.h. Systemänderungen, die Fehler verursachen). +
-  * Nachdem Sie Ihren Code geändert haben, **müssen** Sie die Testsuite ausführen! Auf diese Weise finden Sie heraus, ob es eine Regression gab (wenn ein Test fehlschlägt).+
  
-===== Unit Tests bilden die Basis der Testpyramide =====+===== Manuell oder automatisiert? ===== 
 +In [[modul:m450:learningunits:lu01:testfall|LU01]] haben Sie Testfälle von Hand durchgeführt und das IST ins Testprotokoll eingetragen. Ein Unit Test macht dasselbe, nur durch ein Programm:
  
-{{:modul:m450:learningunits:lu03:testpyramide.png?600|}}+^                         ^ Manueller Test                         ^ Automatisierter Unit Test                     ^ 
 +^ Durchführung            | Eine Person gibt Daten ein und schaut  | Ein Testprogramm ruft den Code auf            | 
 +^ SOLL/IST-Vergleich      | Von Auge                               | Mit ''assert'' im Testcode                    | 
 +^ Dauer                   | Minuten bis Stunden                    | Sekunden, auch für Hunderte von Tests         | 
 +^ Wiederholung            | Aufwändig, wird oft weggelassen        | Nach jeder Änderung, ohne Mehraufwand         | 
 +^ Geeignet für            | Benutzeroberfläche, Bedienbarkeit, Abnahme | Berechnungen, Logik, Fehlerbehandlung     |
  
-===== Wie sind Unit Tests zu implementieren? =====+Der grösste Vorteil ist der **Regressionstest**: Wer Code ändert, startet die ganze Testsuite neu und merkt sofort, ob die Änderung etwas kaputt gemacht hat.
  
-So wie es die [[https://en.wikipedia.org/wiki/SOLID|SOLID Principles]] für die Programmierung im Allgemeinen haben, gibt es auch Prinzipien für allgemeine bewährte Verfahren beim Unit Testing: die **FIRST Principles**. Gehen wir sie durch.+===== Unit Test und Integrationstest ===== 
 +^                       ^ Unit Test                                  ^ Integrationstest                                   ^ 
 +^ Prüft                 | eine einzelne Funktion oder Methode       | das Zusammenspiel mehrerer Units                   | 
 +^ Abhängigkeiten        | werden ersetzt (Stub, Mock)               | sind echt (Datenbank, Datei, andere Klassen)       | 
 +^ Findet typischerweise | Rechenfehler, falsche Bedingungen         | falsche Schnittstellen, vertauschte Parameter      | 
 +^ Geschwindigkeit       | sehr schnell                              | langsamer                                          | 
 +^ Im Modul              | LU03, LU04                                | [[modul:m450:learningunits:lu15:start|LU15]]       |
  
-==== [F]ast ====+Unit Tests bilden die breite Basis der Testpyramide: Es gibt viele davon, sie sind billig und schnell. Weiter oben folgen weniger, dafür aufwändigere Tests (siehe auch [[modul:m450:learningunits:lu01:teststufen|LU01e - Teststufen]]).
  
-Sie **sollten nicht** zögern, die Testsuite zu jedem Zeitpunkt des Entwicklungszyklus auszuführen, selbst wenn es Tausende von Unit Tests gibt. Sie sollten in Sekundenschnelle ausgeführt werden. Wenn die Ausführung eines Tests zu lange dauert, leistet dieser wahrscheinlich mehr, als er sollte – und ist daher kein **Unit** Test!+{{:modul:m450:learningunits:lu03:testpyramide.png?600|Testpyramide}}
  
-==== [I]ndependent resp. [I]solated ====+==== Isolation ==== 
 +Ruft die getestete Funktion etwas auf, das wir nicht kontrollieren, ist der Test nicht mehr isoliert. Typische Beispiele: 
 +  * Benutzereingaben mit ''input()'' 
 +  * Dateien, Datenbanken, Netzwerk 
 +  * Zufallszahlen oder die aktuelle Uhrzeit
  
-Jeder einzelne Test sollte **unabhängig** von allen anderen sein, damit seine Ergebnisse **nicht** von anderen Faktoren beeinflusst werden. Mit dieser Definition sollten Sie normalerweise den „3 A’s des Testens“ folgen: **Arrange, Act, Assert** (auch bekannt als „Given-When-Then“).+Solche Abhängigkeiten ersetzen wir im Test durch Platzhalter. Wie das mit PyTest geht, sehen Sie in [[.:inputoutput|LU03c]], [[modul:m450:learningunits:lu04:monkeypatch|LU04b]] und [[modul:m450:learningunits:lu11:mock|LU11b]].
  
-  * **Arrange:** Alle erforderlichen Daten sollten dem Test in diesem Abschnitt zur Verfügung gestellt werden und diese sollten **nicht** von Ihrer Umgebung abhängen. +===== Aufbau: Arrange – Act – Assert ===== 
-  * **Act:** Hier führen Sie die zu testende Methode aus. +Jeder Unit Test hat drei Teile:
-  * **Assert:** Unit Tests haben möglichst nur **ein** Ergebnis. Das bedeutet, dass pro Test nur **ein** bestimmter Zustand eines Objekts überprüft werden sollte. Dies bedeutet, dass sich **alle** getesteten Variablen auf die von Ihnen ausgeführte Methode beziehen sollten.+
  
-==== [R]epeatable ====+  * **Arrange:** Alles vorbereiten, was der Test braucht: Objekte erzeugen, Testdaten festlegen. 
 +  * **Act:** Die zu testende Funktion oder Methode genau **einmal** aufrufen. 
 +  * **Assert:** Das Ergebnis mit dem SOLL vergleichen.
  
-Tests sollten wiederholbar und deterministisch sein: d.h. das Ergebnis ist jedes Mal dasselbe und zwar unabhängig von der Umgebung.+<code python> 
 +def test_deposit(): 
 +    # Arrange 
 +    account = BankAccount('Anna', 100.0) 
 +    # Act 
 +    account.deposit(50.0) 
 +    # Assert 
 +    assert account.balance == 150.0 
 +</code>
  
-==== [S]self-Validating ====+In der Sprache von Behaviour Driven Development ([[modul:m450:learningunits:lu16:start|LU16]]) heissen die drei Teile **Given – When – Then**.
  
-Der Test selbst sollte Ihnen sagen, ob er bestanden wurde. Eine manuelle Überprüfung der Werte sollte nicht erforderlich sein. Die meisten Bibliotheken (wie ''%%pytest%%'', siehe [[https://docs.pytest.org/en/7.1.x/getting-started.html|Doku]]) arbeiten zugunsten dieses Prinzips.+===== Die FIRST-Prinzipien ===== 
 +Gute Unit Tests erfüllen fünf Eigenschaften:
  
-==== [T]horough ====+^ Prinzip                 ^ Bedeutung                                                              ^ Verstoss, Beispiel                                              ^ 
 +| **F**ast                | Die ganze Testsuite läuft in Sekunden. Man startet sie deshalb oft.   | Ein Test lädt jedes Mal eine grosse Datei aus dem Internet.      | 
 +| **I**ndependent         | Jeder Test läuft für sich allein und in beliebiger Reihenfolge.        | Test B funktioniert nur, wenn Test A vorher ein Konto angelegt hat. | 
 +| **R**epeatable          | Gleiche Ausgangslage, gleiches Ergebnis, auf jedem Computer.           | Das Ergebnis hängt vom heutigen Datum oder von Zufallszahlen ab. | 
 +| **S**elf-validating     | Der Test meldet selbst «bestanden» oder «fehlgeschlagen».              | Der Test gibt Werte mit ''print()'' aus, die man von Auge prüfen muss. | 
 +| **T**imely / **T**horough | Tests entstehen rechtzeitig, idealerweise vor dem Code (TDD), und decken nicht nur den Normalfall ab. | Es gibt nur einen Test mit gültigen Werten. |
  
-Ihr Test sollte alle //„glücklichen Pfade“// einer Methode abdecken, alle Randfälle (bei denen Sie glauben, dass der Test fehlschlagen könnte), illegale Argumente, Sicherheitslücken, grosse Wert etc. Mit anderen Worten: jedes mögliche Szenario sollte getestet werden und nicht nur genug, um eine (nahezu) 100%ige Codeabdeckung zu haben. +<WRAP center round tip 80%> 
- +**Thorough** heisst: Normalfälle, Grenzwerte, Spezialfälle (leere Liste, 0, sehr grosse Zahl) und ungültige Eingaben testen. Hohe Codeabdeckung allein genügt nicht (siehe [[modul:m450:learningunits:lu02:coverage|LU02c]]). 
-==== Das zusätzliche T: Timely ==== +</WRAP>
- +
-Gemäss [[wpde>Testgetriebene_Entwicklung|TDD]] sollten Komponententests **vor** dem zu testenden Produktionscode geschrieben werden. Dies geschieht, indem die Abstraktion (Schnittstelle) und dann der Test allein auf der Grundlage der Methodensignatur und -spezifikation geschrieben wird. Nachdem der Test geschrieben ist, kann der produktive Code implementiert und direkt getestet werden.+
  
 +===== Kontrollfragen =====
 +  - Was ist der Unterschied zwischen einem Unit Test und einem Integrationstest? Nennen Sie je ein Beispiel.
 +  - Warum lohnt sich das Automatisieren besonders für Regressionstests?
 +  - Eine Funktion liest den Preis eines Artikels aus einer Datenbank und berechnet den Rabatt. Was müssen Sie tun, damit der Test der Rabattberechnung isoliert ist?
 +  - Welches FIRST-Prinzip verletzt ein Test, der nur am Vormittag besteht?
 +  - Markieren Sie in einem Ihrer Tests aus LU03.A01 die Teile Arrange, Act und Assert.
  
 ---- ----
-{{tag>M450-LU03}} +{{tag>M450-LU03 M450-C2B}} 
-**Credits**: Der Inhalt dieses Artikels wurde grösstenteils direkt aus dem Englischen übernommen und nur leicht modifiziert. Das Original stammt aus diesem [[https://dev.to/mundim/writing-your-f-i-r-s-t-unit-tests-1iop|Beitrag der DEV Community]], verfasst von [[https://dev.to/mundim|Lucas Fonseca Mundim]]+[[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] Marcel Suter 
  • modul/m450/learningunits/lu03/unittest.txt
  • Zuletzt geändert: 2026/11/17 07:56
  • von admin