{"canonical_url":"https://engineer.company/de/glossary/unit-test/","content_markdown":"# Unittest\n\n## Was es ist\n\nEin Unittest ist eine kleine automatisierte Prüfung eines einzelnen Codeteils für\nsich: Er ruft eine Funktion, Klasse oder ein kleines Modul mit ausgewählten Eingaben\nauf und prüft per Assertion, ob das Ergebnis dem erwarteten entspricht. Solche Tests\nsind meist so ausgelegt, dass sie im selben Prozess wie der geprüfte Code laufen,\nschnell fertig werden und weder Netzwerk noch Datenbank oder Browser brauchen. Das\nsind nützliche Entscheidungen zu Ressourcen und Isolation, keine Garantien, die sich\nallein aus dem engen Testumfang ergeben. Die Praxis heißt meist Unit-Testing; die\nSammlung solcher Tests eines Projekts ist seine Unittest-Suite.\n\nWas als Einheit zählt, ist weniger eindeutig, als der Name vermuten lässt. Im\nKapitel über Unittests in _Software Engineering at Google_ verwendet Erik Kuefler den\nBegriff für Tests mit relativ engem Umfang, etwa einer einzelnen Klasse oder Methode.\nEr ergänzt, dass eine Einheit von einer einzelnen Funktion bis zu mehreren\nzusammengehörigen Paketen reichen kann. Sinnvoll ist die Grenze an der von außen aufgerufenen Schnittstelle: Eine Einheit ist das, was eine Schnittstelle anbietet, auf die sich jemand\naußerhalb verlässt. Ihre Tests benutzen diese Schnittstelle wie der aufrufende Code.\n\nModerne Frameworks haben gemeinsame Vorfahren. Kent Becks Aufsatz _Simple Smalltalk\nTesting: With Patterns_ beschrieb ein kleines Framework aus Fixtures, Testfällen,\nPrüfungen und Suiten und riet Entwicklern, ihre Unittests selbst zu schreiben, einen\nfür jede Klasse. Pythons `unittest` nennt in seiner Dokumentation JUnit als\nursprüngliche Inspiration und behält dieselben vier Begriffe bei: Test-Fixture\n(die Vorbereitung für einen Test und das Aufräumen danach), Testfall (die einzelne\nTesteinheit), Testsuite und Test-Runner. Beide ziehen eine wichtige Grenze: Ein\nFehlschlag liegt vor, wenn eine Prüfung eine falsche Antwort bekommt; ein Fehler ist etwas,\ndas der Test überhaupt nicht vorausgesehen hat, etwa eine tief im Code ausgelöste\nException.\n\nUnittests stehen am engen Ende eines Spektrums. Adam Benders Testkapitel im selben\nBuch ordnet Tests nach ihrem Umfang: Tests mit engem Umfang heißen gewöhnlich\nUnittests, solche mit mittlerem Umfang, die einige Komponenten gemeinsam prüfen,\nIntegrationstests, und solche mit großem Umfang, die das gesamte System durchlaufen,\nEnd-to-End-Tests.\n\n## Warum es wichtig ist\n\nGeschwindigkeit ist der erste Grund. Ein kleiner, isolierter Unittest läuft im\nselben Prozess wie der geprüfte Code. Eine Entwicklerin kann daher an einem\ngewöhnlichen Arbeitstag Tausende davon ausführen; ein Fehler zeigt sich, während die\nverursachende Änderung noch auf dem Bildschirm steht. Googles Vorgaben sind bei den\nerlaubten Mitteln eindeutig: Ein kleiner Test darf weder schlafen noch I/O ausführen\nnoch auf Netzwerk oder Datenträger zugreifen. Diese Grenzen erleichtern schnelle,\nwiederholbare Tests, und ein Team lernt, einer Suite zu vertrauen, die jedes Mal\ndieselbe Antwort gibt.\n\nDer zweite Grund ist die Diagnose. Scheitert ein Test mit engem Umfang, liegt der\nDefekt in einem kleinen Codeteil, meist im gerade geänderten. Scheitert ein Test,\nder das ganze System durchläuft, kann der Defekt irgendwo zwischen Browser und\nDatenbank liegen. Deshalb beschreibt _Software Engineering at Google_ eine Pyramide\nals grobe Richtschnur: etwa 80 Prozent Tests mit engem Umfang, 15 Prozent\nIntegrationstests und 5 Prozent End-to-End-Tests.\n\nDer dritte Grund ist Veränderung. Eine Suite, die Verhalten über eine öffentliche\nSchnittstelle prüft, lässt den Code dahinter ohne Angst umstrukturieren: Bestehen\ndie Tests weiterhin, erhält aufrufender Code weiterhin das erwartete Verhalten. Kueflers Ideal ist\nein Test, der sich nur ändern muss, wenn sich die Anforderungen ändern. Reines\nRefactoring berührt deshalb keinen Test.\n\nUnittests dokumentieren auch. Ein nach einem Verhalten benannter Test mit einfachen\nEingaben und vollständig ausgeschriebenem Erwartungswert zeigt der nächsten lesenden\nPerson, wie der Code aufgerufen werden soll und was er zusagt. Anders als ein\nKommentar schlägt er fehl, wenn das nicht mehr stimmt.\n\n## Wie es in der Praxis aussieht\n\nAls Beispiel dient eine Funktion, die Zeitdauern wie `1h30m` aus einer\nKonfigurationsdatei liest und in Sekunden umwandelt:\n\n```python\n# durations.py\nUNITS = {\"h\": 3600, \"m\": 60, \"s\": 1}\n\n\ndef to_seconds(text: str) -\u003e int:\n    \"\"\"Turn \"1h30m\" or \"45s\" into a whole number of seconds.\"\"\"\n    total, digits = 0, \"\"\n    for char in text:\n        if char.isdigit():\n            digits += char\n        elif char in UNITS and digits:\n            total += int(digits) * UNITS[char]\n            digits = \"\"\n        else:\n            raise ValueError(f\"not a duration: {text!r}\")\n    if digits or not text:\n        raise ValueError(f\"not a duration: {text!r}\")\n    return total\n```\n\nIhre mit pytest geschriebenen Unittests prüfen zwei Verhaltensweisen: was sie\nakzeptiert und was sie zurückweist.\n\n```python\n# test_durations.py\nimport pytest\n\nfrom durations import to_seconds\n\n\n@pytest.mark.parametrize(\n    \"text,expected\",\n    [(\"45s\", 45), (\"2m\", 120), (\"1h30m\", 5400), (\"0s\", 0)],\n)\ndef test_counts_each_unit(text, expected):\n    assert to_seconds(text) == expected\n\n\n@pytest.mark.parametrize(\"text\", [\"\", \"90\", \"h\", \"1x\", \"1.5h\"])\ndef test_refuses_what_it_cannot_read(text):\n    with pytest.raises(ValueError):\n        to_seconds(text)\n```\n\nEin Aufruf von `pytest` im Verzeichnis sammelt alle Dateien namens `test_*.py` oder\n`*_test.py` ein. Die beiden Funktionen ergeben neun Fälle, einen pro Parameterzeile.\nDie pytest-Dokumentation beschreibt jeden Test als Arrange, Act, Assert und Cleanup,\nalso Vorbereiten, Handeln, Prüfen und Aufräumen. Hier ist die Vorbereitung die\nParameterzeile, die Handlung der einzelne Aufruf, und es gibt nichts aufzuräumen,\nweil nichts außerhalb der Funktion berührt wird. Setzt jemand später versehentlich\ndie Minute auf 3.600 Sekunden, schlagen zwei Fälle fehl, und der Bericht benennt\njeden anhand seiner Parameter: `test_counts_each_unit[2m-120]` zeigt 7.200 statt der\nerwarteten 120, und `test_counts_each_unit[1h30m-5400]` zeigt 111.600 statt 5.400. Die\nErwartungswerte sind von Hand berechnet und nicht aus der Ausgabe des ersten\nProgrammlaufs übernommen.\n\nDieselben Prüfungen würden mit `unittest` aus der Standardbibliothek in einer\nUnterklasse von `unittest.TestCase` stehen, deren Methodennamen mit `test` beginnen\nund die `assertEqual` und `assertRaises` verwendet. `python -m unittest` findet standardmäßig Dateien,\ndie `test*.py` entsprechen. Go verankert die Konvention in der Werkzeugkette: Eine\nFunktion `func TestXxx(t *testing.T)` in einer Datei mit der Endung `_test.go` wird\nvon `go test` ausgeführt.\n\nMit der Größe ändert sich die Buchführung, nicht die Idee. Der\n[Datenbankgenerator, der an 981 Testfällen gemessen wird](/de/portfolio/held-the-generator-to-981-tests-and-92-coverage/),\neine Arbeit vom Juli 2026, zählt 383 Testfunktionen, die nach Auflösung der\nParametrisierung 981 Fälle ergeben, verteilt auf 45 Dateien und 7.944 Zeilen. Sein\nBuild erzwingt eine Untergrenze von 92 Prozent Zweigabdeckung bei etwa 95 Prozent\ngemessener Abdeckung und behandelt Warnungen als Fehlschläge. Die Seite benennt\noffen die Grenze dieser Zahl: Zwei später gefundene Defekte lagen in Code, den der\nAbdeckungsbericht als abgedeckt auswies.\n\n## Wo es schiefgeht\n\n**Die Tests spiegeln die Implementierung.** Ein Test, der in private Hilfsfunktionen\ngreift oder die genaue Reihenfolge interner Aufrufe prüft, scheitert bei jeder\nUmstrukturierung, obwohl sich aus Sicht des aufrufenden Codes nichts geändert hat.\nKuefler nennt solche Tests brüchig und die übermäßige Abhängigkeit von Mocking-Frameworks\nals häufigsten Grund für problematische Interaktionstests. Getestet werden sollte\nüber die öffentliche Schnittstelle: der entstehende Zustand statt der Aufrufe auf\ndem Weg dorthin, mit echten Objekten, wo ihr Einsatz wenig Aufwand verursacht.\n\n**Tests hängen voneinander ab.** Ein Test legt einen Datensatz an, der nächste liest\nihn, und die Suite läuft nur in dieser Reihenfolge fehlerfrei durch. Ein einzelner Test oder\ndieselben Tests in anderer Reihenfolge scheitern dann ohne erkennbaren Grund. Becks\nFramework erzeugte und verwarf seine Testdaten für jeden Test; die Dokumentation von\n`unittest` verlangt, dass ein Testfall vollständig eigenständig ist. Jeder Test\nbraucht seine eigene Fixture und muss hinter sich aufräumen.\n\n**Abdeckung wird zum Ziel.** Abdeckung zeigt, dass eine Zeile ausgeführt wurde, nicht,\ndass etwas ihr Verhalten geprüft hat. Ein Test ohne Assertion erhöht die Zahl und\nbeweist nichts. _Software Engineering at Google_ warnt, dass eine Vorgabe von\n80 Prozent leicht zur Obergrenze wird und Änderungen genau beim Minimum landen.\nDie Zahl sollte als Untergrenze dienen; im Review sind die Assertions zu lesen.\n\n**Ein Test pro Methode.** Jede Produktionsmethode einer Testmethode zuzuordnen wirkt\nordentlich. Doch der Test wächst mit jedem neuen Zweig der Methode, bis niemand mehr\nsagen kann, was er prüft. Kuefler rät stattdessen, Verhalten zu testen: eine\nVerhaltensweise pro Test, benannt nach dem, was er nachweist. So liest sich der\nFehlerbericht als Satz darüber, was nicht mehr funktioniert.\n\n**Der Test wartet, bis Zeit vergeht.** Ein `sleep()`, das auf den Abschluss von etwas\nwartet, verlangsamt die Suite bei jedem Lauf und scheitert trotzdem auf einer\nausgelasteten Maschine. In einem Unittest ist Zeit eine Eingabe: Eine Uhr oder ein\nZeitstempel wird übergeben, damit der Test den benötigten Zeitpunkt selbst setzen kann,\nstatt darauf zu warten.\n\n## Weiterführende Lektüre\n\n- [unittest: Unit testing framework](https://docs.python.org/3/library/unittest.html)\n  — das Framework der Python-Standardbibliothek: Fixtures, Testfälle, Suiten, Runner,\n  Testermittlung und der Unterschied zwischen Fehlschlag und Fehler.\n- [Anatomy of a test](https://docs.pytest.org/en/stable/explanation/anatomy.html)\n  — pytest erklärt Arrange, Act, Assert und Cleanup.\n- [Get Started](https://docs.pytest.org/en/stable/getting-started.html)\n  — die Einführung von pytest selbst: einfaches `assert`, Testermittlung und\n  `pytest.raises`.\n- [Unit Testing](https://abseil.io/resources/swe-book/html/ch12.html)\n  — Erik Kueflers Kapitel in _Software Engineering at Google_ über brüchige Tests,\n  öffentliche APIs, Zustände gegenüber Interaktionen und das Testen von Verhalten.\n- [Simple Smalltalk Testing: With Patterns](https://web.archive.org/web/20150315073817/http://www.xprogramming.com/testfram.htm)\n  — Kent Becks Aufsatz über das Framework, die Begründung für einen selbst geschriebenen\n  Unittest pro Klasse und Fehlschläge gegenüber Fehlern, in einer archivierten Fassung.\n- [testing](https://pkg.go.dev/testing)\n  — Gos Standard-Testpaket: `TestXxx`-Funktionen, `_test.go`-Dateien und `go test`.\n\n\u003chttps://engineer.company/de/glossary/unit-test/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Was als Einheit gilt, wie ein Test schnell und unabhängig bleibt, ein ausgearbeitetes pytest-Beispiel und die Gewohnheiten, die Tests brüchig machen.","formats":{"gemtext":"https://engineer.company/de/glossary/unit-test/index.gmi","gopher":"https://engineer.company/de/glossary/unit-test/gophermap","html":"https://engineer.company/de/glossary/unit-test/","json":"https://engineer.company/de/glossary/unit-test/index.json","markdown":"https://engineer.company/de/glossary/unit-test/index.md","pdf":"https://engineer.company/de/glossary/unit-test/index.pdf"},"kind":"page","language":"de","title":"Was ist ein Unittest?","url":"https://engineer.company/de/glossary/unit-test/","version":1}