Unit, Integrations und End to End Tests: was wo getestet wird
Kurz gesagt
Niveau: Fortgeschritten
Teste jedes Verhalten auf der tiefsten Ebene, die es beweisen kann.
- Unit Tests prüfen eine Regel für sich, in Millisekunden, also schreibst du viele.
- Integrationstests prüfen das Zusammenspiel der Teile, mit Fakes für fremde Dienste.
- End to End Tests steuern einen echten Browser durch die Abläufe, die Geld bringen, und bleiben wenige, weil sie langsam und anfällig sind.
- Gib jeder Ebene ein Zeitbudget.
- Behandle wackelige Tests als Fehler: Bei n Tests mit je der Wahrscheinlichkeit p für einen zufälligen Fehlschlag ist ein Lauf mit 1 minus (1 minus p) hoch n grundlos rot, bei 200 Tests und 0,5 % rund 63 %.
Wer Tests zuerst schreibt, steht bald vor der nächsten Frage: welche Tests, und wie viele von jeder Sorte? Hier ist eine klare Antwort: die drei Ebenen, die Pyramide und ihre Kritik, Stellvertreter für fremde Dienste, ein Zeitbudget je Ebene und warum ein paar wackelige Tests eine ganze Testsammlung entwerten. Alles gezeigt an einem Checkout eines Grazer Teeshops, getestet auf drei Ebenen.
Welche Tests brauche ich, und wie viele von jeder Sorte?
Sobald du deinen ersten Test vor dem Code geschrieben hast, kommt fast sofort die nächste Frage. Es gibt viele Arten von Tests, und jeder Ratgeber nennt sie ein bisschen anders: Unit, Integration, funktional, Abnahme, System, End to End. Welche braucht ein echtes Produkt? Wie viele von jeder Sorte? Und wohin gehört eine bestimmte Prüfung?
Darum geht es hier, in klaren Worten, für Entwicklerinnen und Entwickler genauso wie für alle, die Software beauftragen und bezahlen. Falls dir automatisierte Tests noch neu sind, fang mit dem ersten Kapitel dieser Serie an: Testgetriebene Entwicklung erklärt. Hier setze ich voraus, dass du weißt, was ein Test ist (vorbereiten, ausführen, prüfen), und wissen willst, wohin der nächste gehört.
Das Beispiel zieht sich durch den ganzen Text: das Teehaus am Grieskai, ein erfundener Onlineshop für Tee in Graz, erreichbar unter teehausgrieskai.example. Er verkauft losen Tee und Abos, nimmt Kartenzahlungen über einen Zahlungsanbieter an, kennt Rabattcodes, führt einen Lagerbestand und verschickt Bestellmails. Entwickelt wird er von Jana. Alle Zahlen zum Teehaus sind für das Beispiel erfunden.
Drei Ebenen, einfach erklärt
Tests unterscheiden sich vor allem in einem Punkt: wie viel vom echten System sie gleichzeitig einschalten. Je mehr sie einschalten, desto mehr beweisen sie, und desto langsamer und anfälliger werden sie. Drei Ebenen decken fast alles ab.
Unit Tests
Ein Unit Test prüft ein kleines Stück Logik für sich allein: eine Funktion, eine Methode, eine Klasse. Er läuft im selben Prozess wie der Code, ohne Datenbank, ohne Netzwerk, ohne Browser. Er ist schnell (ein paar Millisekunden), und wenn er fehlschlägt, zeigt er auf genau eine Stelle.
Das Engineering Buch von Google nennt solche Tests kleine Tests und definiert sie über das, was sie anfassen dürfen: Kleine Tests laufen in einem einzigen Prozess1. Diese Definition hilft mehr als der Name. Braucht ein Test eine Datenbank, ist er nicht mehr klein, egal wie du ihn nennst.
Integrationstests
Ein Integrationstest prüft, ob mehrere Teile zusammenarbeiten: dein Code und die Datenbank, dein Code und der Mailversand, ein Controller und das Modell dahinter. Er läuft weiterhin auf einer Maschine, aber jetzt reden echte Teile miteinander. Die mittleren Tests bei Google dürfen mehrere Prozesse umfassen und Netzwerkaufrufe machen, aber nur zur eigenen Maschine1. In Rails liegen Integrationstests in test/integration und steuern die App über ihre Routen, während Modell und Servicetests dieselbe Basisklasse wie Unit Tests nutzen, aber meist die echte Testdatenbank berühren2.
Was ein Integrationstest nicht tut: Dienste aufrufen, die dir nicht gehören, etwa den echten Zahlungsanbieter. Die werden durch einen Stellvertreter ersetzt, dazu gleich mehr.
End to End Tests
Ein End to End Test bedient die ganze Anwendung so, wie es die Kundschaft tut: Ein echter Browser öffnet eine Seite, füllt Felder aus, klickt Buttons und liest das Ergebnis. Rails nennt das Systemtests. Sie liegen in test/system, steuern den Browser mit der Bibliothek Capybara, und bin/rails test führt sie standardmäßig nicht einmal aus: Du rufst sie mit bin/rails test:system oder bin/rails test:all auf2. In JavaScript Projekten übernimmt diese Aufgabe oft Playwright.
End to End Tests beweisen am meisten, weil zwischen Kundschaft und Datenbank nichts ersetzt ist. Sie sind aber auch die langsamsten, oft mehrere Sekunden pro Test, und sie scheitern am ehesten aus Gründen, die mit deinem Code nichts zu tun haben.
Beispiel: ein Rabattcode, drei Ebenen
Das Teehaus hat einen Code, BLATT10, für 10 % Rabatt. So sähe die Prüfung auf jeder Ebene aus.
- Unit: Bei einem Warenkorb von € 44,00 und dem Code BLATT10 liefert der Preisrechner € 39,60. Reine Rechnung, keine Datenbank, rund eine Millisekunde.
- Integration: Wird eine Bestellung mit BLATT10 aufgegeben, hält die gespeicherte Bestellung den Code, den Rabatt von € 4,40 und die richtige Summe fest, und der Nutzungszähler des Codes steigt um eins. Echte Datenbank, nachgebauter Zahlungsanbieter.
- End to End: Eine Kundin tippt BLATT10 im Checkout eines echten Browsers ein, sieht "BLATT10 eingelöst, du sparst € 4,40" und zahlt den reduzierten Betrag.
Alle drei drehen sich um dieselbe Regel, und jede Ebene beweist etwas, das die anderen nicht können. Der Unit Test beweist die Rechnung. Der Integrationstest beweist, dass sie gespeichert wird. Der End to End Test beweist, dass ein Mensch sie tatsächlich nutzen kann. Bleibt die Frage, wie viele du von jeder Sorte brauchst. Hier kommt die Pyramide ins Spiel.
Die Testpyramide, und warum sie so aussieht
Die bekannteste Antwort ist die Testpyramide. Mike Cohn hat sie um 2003 und 2004 im Gespräch mit Lisa Crispin skizziert und 2009 in seinem Buch Succeeding with Agile als "Test Automation Pyramid" bekannt gemacht3. Das Bild ist einfach: unten eine breite Schicht Unit Tests, in der Mitte eine Schicht Service oder Integrationstests, oben eine schmale Spitze mit Tests über die Oberfläche.
Ham Vocke fasst sie in seinem langen Artikel auf der Seite von Martin Fowler in zwei Regeln: Schreib Tests in unterschiedlicher Granularität, und je höher die Ebene, desto weniger Tests solltest du haben4. Fowler begründet die schmale Spitze: Tests über die Oberfläche sind brüchig, teuer zu schreiben und zeitraubend in der Ausführung3.
Das Buch von Google nennt grobe Zahlen: rund 80 % Unit Tests, 15 % Integrationstests und 5 % End to End Tests, mit dem ausdrücklichen Hinweis, dass jedes Team seine eigene Mischung hat1. Es benennt auch die Form, die du vermeiden solltest, das Eisstanitzel: viele End to End Tests und darunter kaum Unit oder Integrationstests. Solche Testsammlungen sind laut dem Buch meist langsam, unzuverlässig und mühsam im Umgang1.
Beispiel: die Tests des Teehauses gezählt
Jana zählt die Tests im Repository des Teehauses. Die Zahlen sind für das Beispiel erfunden.
Das sind 798 Tests insgesamt. Die Anteile: 640 von 798, also rund 80 %, dann 140 von 798, rund 18 %, und 18 von 798, rund 2 %. Das liegt eh nah an der Form, die Google vorschlägt, etwas schwerer in der Mitte und etwas leichter an der Spitze. Das passt. Die Pyramide ist eine Faustregel, keine Quote. Entscheidend ist, dass die Basis breit und die Spitze schmal ist, und warum, zeigt der Abschnitt über Geschwindigkeit.
Die Kritik: die Testtrophäe
Nicht alle zeichnen eine Pyramide. Kent C. Dodds, der JavaScript Testing unterrichtet, hat 2018 die Testing Trophy vorgeschlagen, eine Trophäe statt einer Pyramide5. Von unten nach oben hat sie vier Schichten: statische Prüfungen (Typprüfung und Linting, die Tippfehler und falsche Typen finden, bevor überhaupt ein Test läuft), dann Unit Tests, dann eine breite Integrationsschicht, oben eine kleine Kappe aus End to End Tests. Ihr Motto stammt von Guillermo Rauch: "Write tests. Not too many. Mostly integration.", also: Schreib Tests, nicht zu viele, vor allem Integrationstests5.
Das Argument ist fair. In einem modernen Frontend beweist ein Unit Test einer winzigen Komponente oft wenig, weil die Fehler im Zusammenspiel von Komponenten, Zustand und Netzwerk stecken. Ein Test, der ein ganzes Formular rendert und ausfüllt, ohne echten Browser, findet für den gleichen Aufwand viel mehr.
Wer hat also recht? Beide, jeweils auf ihrem Terrain. Die Pyramide stammt aus serverseitigem Code, wo Geschäftsregeln in einfachen Objekten stecken, die sich gut einzeln testen lassen. Die Trophäe stammt aus Browsercode, wo das spannende Verhalten in der Verdrahtung liegt. Beim Wichtigsten sind sich beide einig: viele schnelle Tests unten, wenige langsame Browsertests oben, und eine bewusste Entscheidung für die Mitte.
Beispiel: zwei Formen in einem Shop
Das Backend des Teehauses ist Rails. Preise, Lager und Aboregeln stecken in kleinen Ruby Klassen, also testet Jana sie mit vielen Unit Tests: pyramidenförmig. Die Aboseite, eine React Komponente in einem Next.js Frontend, lässt die Kundschaft Tee, Packungsgröße und Lieferrhythmus wählen. Jana testet sie vor allem, indem sie das ganze Formular rendert, Optionen auswählt und die angezeigte Zusammenfassung prüft, wobei der Netzwerkaufruf ans Backend ersetzt ist. Dieser Teil der Tests hat die Form einer Trophäe. Keine der beiden Formen ist falsch. Jede passt dorthin, wo die Fehler tatsächlich wohnen.
Test Doubles: Stubs, Mocks, Fakes und Spies
Integrationstests ersetzen die Dienste, die dir nicht gehören. Der Oberbegriff für jeden Stellvertreter ist Test Double, nach dem Stuntdouble im Film. Das kurze Glossar von Martin Fowler, aufbauend auf dem Vokabular von Gerard Meszaros, kennt fünf Arten6.
- Dummy: ein Objekt, das nur herumgereicht wird, um eine Parameterliste zu füllen, und nie wirklich benutzt wird.
- Stub: liefert vorbereitete Antworten auf die Aufrufe im Test und ignoriert alles andere.
- Spy: ein Stub, der zusätzlich mitschreibt, wie er aufgerufen wurde, damit der Test es danach prüfen kann.
- Mock: vorab mit den erwarteten Aufrufen programmiert, und der Test scheitert, wenn die Aufrufe abweichen.
- Fake: eine echte, funktionierende Umsetzung mit einer Abkürzung, etwa eine Datenbank im Arbeitsspeicher, nicht für die Produktion geeignet.
Noch eine Unterscheidung lohnt sich, aus Fowlers Essay Mocks Aren't Stubs. Ein Test kann den Zustand am Ende prüfen (ist die Bestellung gespeichert, ist der Bestand gesunken?) oder das Verhalten unterwegs (hat der Code charge mit diesen Argumenten aufgerufen?). Mocks prüfen immer das Verhalten7. Zustandsprüfungen überstehen Umbauten meist besser, weil ihnen egal ist, auf welchem Weg der Code zum Ergebnis kommt. Verhaltensprüfungen sind richtig, wenn der Aufruf selbst der Punkt ist, etwa "genau eine Abbuchung beim Zahlungsanbieter".
Beispiel: der Zahlungsanbieter, auf vier Arten ersetzt
Der Checkout des Teehauses ruft ein Gateway Objekt mit charge(amount_cents:, token:, idempotency_key:) auf. Jana kann das Gateway auf verschiedene Arten ersetzen.
Ein Stub antwortet nur:
stub_gateway = Object.new
def stub_gateway.charge(**) = { ok: true, reference: "stub_1" }
Die erste Zeile erzeugt ein leeres Objekt. Die zweite gibt ihm eine Methode charge, die beliebige Schlüsselwortargumente annimmt und immer meldet, die Zahlung habe geklappt. Nützlich, wenn es im Test um etwas anderes geht, etwa die Bestätigungsseite.
Ein Mock weiß, was er erwartet, und beschwert sich sonst:
gateway = Minitest::Mock.new
gateway.expect(:charge, { ok: true, reference: "m_1" },
amount_cents: 2895, token: "tok_visa", idempotency_key: String)
PlaceOrder.new(gateway:).call(basket:, card_token: "tok_visa")
gateway.verify
expect sagt: Es kommt genau ein Aufruf von charge, mit exakt 2.895 Cent, diesem Token und irgendeinem Text als Schlüssel, und das hier gibst du zurück. verify am Ende lässt den Test scheitern, wenn dieser Aufruf nie stattfand. Richtig für "wir buchen genau einmal ab, den richtigen Betrag".
Ein Fake, der gleichzeitig ein Spy ist, verhält sich wie ein kleiner echter Anbieter und führt Buch:
# test/support/fake_payment_gateway.rb
class FakePaymentGateway
attr_reader :charges
def initialize(decline: false)
@decline = decline
@charges = []
end
def charge(amount_cents:, token:, idempotency_key:)
# jede Abbuchung mitschreiben, damit der Test sie später prüfen kann
@charges << { amount_cents:, token:, idempotency_key: }
return { ok: false, reason: "card_declined" } if @decline
{ ok: true, reference: "fake_#{@charges.size}" }
end
end
Er startet mit einer leeren Liste von Abbuchungen. Jeder Aufruf fügt einen Eintrag hinzu, so kann ein Test später charges lesen und den Betrag prüfen (das ist der Spy Teil). Mit decline: true erzeugt, lehnt er jede Karte ab, so wie es ein echter Anbieter tun würde. Jana nutzt diesen Fake in den meisten Integrationstests, weil eine kleine Klasse den Gutfall und die abgelehnte Karte gleichermaßen abdeckt.
Die Gefahr bei jedem Double ist Drift: Der echte Anbieter ändert sich, das Double nicht. Der Artikel über TDD und BDD für APIs zeigt, wie Contract Tests ein Double ehrlich halten. Das Buch von Google macht denselben Punkt mit Zahlen: Zwei Doubles, die jeweils ein wenig danebenliegen, vervielfachen ihre Fehler, sobald die Teile zusammenkommen8.
Zeitbudgets: was jede Ebene kosten darf
Ein Test, den du nicht ausführst, schützt nichts. Das Buch von Google sagt es nüchtern: Je langsamer ein Test, desto seltener führt ihn jemand aus8. Vocke schreibt, dass ein ordentlicher Rechner Tausende Unit Tests in wenigen Minuten schafft und dass eine Pipeline die schnellen Tests zuerst laufen lassen sollte, damit ein Fehler so früh wie möglich auffällt4.
Ein Zeitbudget macht daraus eine Regel, die du prüfen kannst. Du legst je Ebene fest, wie lange ein einzelner Test und wie lange die ganze Ebene dauern darf, und behandelst eine Überschreitung wie einen fehlschlagenden Test. Einen offiziellen Standard für die Werte gibt es nicht. Ein vernünftiger Startpunkt, den du an dein Projekt anpasst:
| Ebene | Ein Test | Die ganze Ebene | Wann sie läuft |
|---|---|---|---|
| Unit | unter 10 Millisekunden | unter 30 Sekunden | bei jedem Speichern |
| Integration | unter 1 Sekunde | unter 2 Minuten | vor jedem Commit |
| End to End | unter 20 Sekunden | unter 10 Minuten | bei jedem Push, in der Continuous Integration |
Zum Vergleich: Große Tests bekommen bei Google ein Standardzeitlimit von 15 Minuten oder einer Stunde8. Ein kleiner Shop braucht nichts davon, und er sollte es auch nicht wollen.
Beispiel: die Tests des Teehauses gestoppt
Jana misst die Laufzeit ihrer Tests auf dem Laptop. Die Werte sind für das Beispiel erfunden.
- 640 Unit Tests zu je etwa 10 Millisekunden: 640 × 0,01 = 6,4 Sekunden.
- 140 Integrationstests zu je etwa 0,25 Sekunden: 140 × 0,25 = 35 Sekunden.
- 18 End to End Tests zu je etwa 12 Sekunden: 18 × 12 = 216 Sekunden.
Die ganze Sammlung braucht 6,4 + 35 + 216 = 257,4 Sekunden, gut vier Minuten. Schau, wo die Zeit hingeht: Die 18 Browsertests sind rund 2 % der Tests und 216 von 257,4 Sekunden, also rund 84 % der Zeit. Jeder neue End to End Test kostet ungefähr so viel Zeit wie tausend Unit Tests. Das ist das Argument der Pyramide in einer Zeile Rechnung, und deshalb fragt Jana vor jedem neuen Browsertest: Könnte eine tiefere Ebene das auch beweisen?
Ausgearbeitetes Beispiel: der Checkout des Teehauses auf drei Ebenen
Jetzt das vollständige Beispiel, jeder Schritt gezeigt. Das Verhalten: Eine Kundin kauft zwei 100 Gramm Packerl Assam Breakfast zu je € 12,50. Unter € 40 berechnet der Shop € 3,95 Versand. Die Kundin zahlt also 2 × € 12,50 + € 3,95 = € 28,95. Geldbeträge werden als ganze Cent gespeichert, damit keine Rundungsfehler entstehen, das sind 2.895 Cent.
Ebene eins: ein Unit Test der Preisberechnung
Der erste Test prüft die Rechnung und sonst nichts.
# test/services/price_calculator_test.rb
require "test_helper"
class PriceCalculatorTest < ActiveSupport::TestCase
test "adds 395 cents shipping below 4000 cents" do
calc = PriceCalculator.new(lines: [{ price_cents: 1250, quantity: 2 }])
assert_equal 2895, calc.total_cents
end
test "ships free from 4000 cents" do
calc = PriceCalculator.new(lines: [{ price_cents: 2000, quantity: 2 }])
assert_equal 4000, calc.total_cents
end
test "applies the discount before deciding on shipping" do
calc = PriceCalculator.new(lines: [{ price_cents: 2200, quantity: 2 }], discount_percent: 10)
assert_equal 3960 + 395, calc.total_cents
end
end
Zeile für Zeile: require "test_helper" lädt die Testumgebung. Die Klasse bündelt die Tests zu einem Thema. Jeder Block test "..." do ist ein Verhalten, in Klartext benannt. Darin baut die erste Zeile einen Rechner mit einem Warenkorb, und assert_equal vergleicht den erwarteten mit dem tatsächlichen Wert. Der dritte Test hält eine geschäftliche Entscheidung fest: € 44,00 minus 10 % sind € 39,60, das liegt unter € 40, also fällt Versand an. Das musste jemand entscheiden, und der Test dokumentiert die Entscheidung jetzt.
Der Code, der diese Tests grün macht, ist klein:
# app/services/price_calculator.rb
class PriceCalculator
SHIPPING_CENTS = 395
FREE_SHIPPING_FROM_CENTS = 4000
def initialize(lines:, discount_percent: 0)
@lines = lines
@discount_percent = discount_percent
end
def total_cents
# Zwischensumme: Preis mal Menge, über alle Positionen
subtotal = @lines.sum { |line| line[:price_cents] * line[:quantity] }
discounted = subtotal - (subtotal * @discount_percent / 100)
# Versand nur unter der Grenze für Gratisversand
discounted + (discounted >= FREE_SHIPPING_FROM_CENTS ? 0 : SHIPPING_CENTS)
end
end
Er addiert Preis mal Menge über alle Positionen, zieht den Rabatt ab und rechnet Versand nur dazu, wenn der reduzierte Betrag unter € 40 liegt. Die drei Tests laufen zusammen in wenigen Millisekunden. Jana kann sie bei jedem Speichern ausführen.
Ebene zwei: ein Integrationstest des Bestellservice
Der zweite Test prüft, ob eine Bestellung mit Datenbank und Mailversand wirklich funktioniert. Der Zahlungsanbieter ist der Fake von vorhin.
# test/services/place_order_test.rb
require "test_helper"
class PlaceOrderTest < ActiveSupport::TestCase
include ActionMailer::TestHelper
setup do
@tea = products(:assam_breakfast) # Fixture: 1250 Cent, 10 auf Lager
@basket = Basket.create!(lines: [BasketLine.new(product: @tea, quantity: 2)])
end
test "a paid order is saved, stock goes down and one email is queued" do
gateway = FakePaymentGateway.new
assert_enqueued_emails 1 do
order = PlaceOrder.new(gateway:).call(basket: @basket, card_token: "tok_visa")
assert order.paid?
end
assert_equal 2895, gateway.charges.first[:amount_cents]
assert_equal 8, @tea.reload.stock
end
test "a declined card leaves the order unpaid and the stock untouched" do
gateway = FakePaymentGateway.new(decline: true)
order = PlaceOrder.new(gateway:).call(basket: @basket, card_token: "tok_declined")
refute order.paid?
assert_equal 10, @tea.reload.stock
end
end
Zeile für Zeile: include ActionMailer::TestHelper holt die Prüfungen für Mails dazu. setup läuft vor jedem Test. Es lädt den Assam aus den Testdaten (einer Fixture, einer kleinen Datei mit Beispieldatensätzen) und speichert einen echten Warenkorb mit zwei Packungen in der Testdatenbank. Der erste Test baut den Fake, dann umschließt er die Bestellung mit assert_enqueued_emails 1, das nur besteht, wenn genau eine Mail zum Versand eingereiht wurde. Darin wird bestellt und geprüft, ob die Bestellung bezahlt ist. Danach liest der Test die Aufzeichnung des Fakes und prüft, dass genau 2.895 Cent abgebucht wurden, und lädt den Tee neu aus der Datenbank, um zu sehen, dass der Bestand von 10 auf 8 gesunken ist.
Der zweite Test nutzt einen Fake, der ablehnt. Er prüft die beiden Dinge, die eine abgelehnte Zahlung nie tun darf: die Bestellung als bezahlt markieren oder Ware aus dem Lager nehmen. Das ist ein erster Blick auf den Unhappy Path, der ein eigenes Kapitel bekommt: den Unhappy Path testen.
Diese Tests brauchen jeweils einen Bruchteil einer Sekunde, weil die Datenbank lokal ist und nichts die Maschine verlässt.
Ebene drei: ein End to End Test des Checkouts
Der letzte Test steuert einen echten Browser durch den ganzen Ablauf.
# test/system/checkout_test.rb
require "application_system_test_case"
class CheckoutTest < ApplicationSystemTestCase
test "a customer buys two packs of Assam and sees the confirmation" do
visit product_path(products(:assam_breakfast))
fill_in "Menge", with: 2
click_on "In den Warenkorb"
click_on "Zur Kasse"
fill_in "E-Mail", with: "sam@teehausgrieskai.example"
click_on "€ 28,95 bezahlen"
assert_text "Danke, deine Bestellung ist bestätigt"
assert_text "€ 28,95"
end
end
Zeile für Zeile: visit öffnet die Produktseite im Browser. fill_in tippt in das Feld mit der Beschriftung Menge, und click_on drückt den Button oder Link mit diesem Text, genau wie die Kundschaft. Dann füllt der Test auf der Kassenseite eine Mailadresse aus und bezahlt. Die beiden Zeilen mit assert_text prüfen, was die Kundin am Ende sieht. In der Testumgebung des Teehauses nutzt die App denselben Fake, es wird also keine echte Karte belastet.
Achte darauf, was dieser Test nicht tut. Er prüft weder die Rabattregeln noch den Lagerbestand noch die abgelehnte Karte. Das ist darunter schneller und genauer bewiesen. Der End to End Test beweist genau eine Sache: Ein Mensch kommt von der Produktseite zu einer bezahlten Bestellung. Deshalb reicht hier einer.
Zahlungsanbieter veröffentlichen außerdem Testkartennummern für ihre Sandbox, die eigene Testumgebung des Anbieters. Die Liste von Stripe beginnt zum Beispiel mit 4242 4242 4242 42429. Ein eigener, langsamerer Lauf gegen diese Sandbox (etwa einmal pro Nacht) prüft, ob die echte Anbindung noch funktioniert, ohne jeden Push zu bremsen.
Ist das Frontend eine eigene JavaScript Anwendung, liest sich derselbe Ablauf in Playwright fast gleich:
// e2e/checkout.spec.ts
import { test, expect } from '@playwright/test';
test('a customer buys two packs of Assam', async ({ page }) => {
await page.goto('/tee/assam-breakfast');
await page.getByLabel('Menge').fill('2');
await page.getByRole('button', { name: 'In den Warenkorb' }).click();
await page.getByRole('link', { name: 'Zur Kasse' }).click();
await page.getByLabel('E-Mail').fill('sam@teehausgrieskai.example');
await page.getByRole('button', { name: '€ 28,95 bezahlen' }).click();
// wartet, bis die Bestätigung sichtbar ist
await expect(page.getByText('Danke, deine Bestellung ist bestätigt')).toBeVisible();
});
getByLabel und getByRole finden Elemente so, wie ein Screenreader es tut, über Beschriftung und Rolle. Das hält den Test nah an dem, was ein Mensch erlebt. Das abschließende expect wartet, bis die Bestätigung sichtbar ist, und genau das wird im nächsten Abschnitt wichtig.
Dieser Checkout ist genau die Art von Ablauf, die nie brechen darf. Wie du solche Abläufe findest und absicherst, zeigt das nächste Kapitel: der kritische Pfad in Software.
Flaky Tests: Tests, die falschen Alarm schlagen
Ein flaky Test (wörtlich: ein wackeliger Test) besteht manchmal und scheitert manchmal, bei exakt demselben Code. Google definiert ein flaky Ergebnis als einen Test, der mit demselben Code sowohl ein bestandenes als auch ein gescheitertes Ergebnis zeigt10.
Solche Tests richten mehr Schaden an, als ihre Zahl vermuten lässt, weil sie allen beibringen, Rot zu ignorieren. Hat sich erst einmal "das ist bestimmt wieder dieser eine Test" eingeschliffen, wird auch ein echter Fehler durchgewunken. John Micco berichtete 2016 im Testing Blog von Google, dass etwa 1,5 % aller Testläufe ein flaky Ergebnis lieferten, dass fast 16 % der Tests eine gewisse Wackeligkeit hatten und dass rund 84 % der beobachteten Wechsel von bestanden zu gescheitert einen flaky Test betrafen10. Meistens, wenn ein Test rot wurde, lag es also nicht am Code. Das Buch von Google ergänzt, dass Tests ab etwa 1 % Wackeligkeit ihren Wert zu verlieren beginnen1.
Woher kommt das? Die erste große Studie, von Luo und Kollegen an der University of Illinois aus dem Jahr 2014, untersuchte 201 Korrekturen an flaky Tests in 51 Open Source Projekten. Von den 161, die sich einordnen ließen, waren 45 % Async Wait (der Test prüfte ein Ergebnis, bevor die asynchrone Arbeit fertig war), 20 % Nebenläufigkeit (mehrere Threads, die sich in die Quere kommen) und 12 % Abhängigkeit von der Reihenfolge (ein Test, der nur besteht, wenn ein anderer vorher lief)11.
Browsertests sind für die erste Ursache besonders anfällig, weil Seiten in ihrem eigenen Tempo laden und sich ändern. Deshalb warten Capybara und Playwright für dich. Capybara sucht ein Element so lange erneut, bis es erscheint, bis zu einer einstellbaren Höchstwartezeit12. Playwright prüft vor jeder Aktion, ob ein Element sichtbar, stabil, klickbar und aktiviert ist, und seine Web First Assertions wiederholen die Prüfung, bis die Bedingung erfüllt ist13. Wer diese Werkzeuge so nutzt wie gedacht, vermeidet die meisten Async Wait Fehler. Wer stattdessen sleep 2 einbaut, lädt sie ein.
Die Mathematik einer Testsammlung mit flaky Tests
Warum wird aus ein bisschen Wackeligkeit pro Test so viel Rot im Build? Weil ein Build rot ist, sobald ein einziger Test scheitert. Angenommen, jeder von Tests scheitert zufällig, unabhängig von den anderen, mit einer kleinen Wahrscheinlichkeit . Dann ist die Wahrscheinlichkeit, dass mindestens einer scheitert, der ganze Lauf also rot ist, obwohl nichts kaputt ist:
Dabei ist die Wahrscheinlichkeit, dass ein Lauf ohne echten Fehler scheitert, die Wahrscheinlichkeit, dass ein Test in einem Lauf zufällig scheitert, und die Zahl solcher Tests in der Sammlung. Schritt für Schritt: ist die Wahrscheinlichkeit, dass ein Test besteht, die Wahrscheinlichkeit, dass alle bestehen (die Wahrscheinlichkeiten werden multipliziert, weil die Tests unabhängig sind), und eins minus das ist die Wahrscheinlichkeit, dass nicht alle bestehen. Wenn dir das Multiplizieren unabhängiger Wahrscheinlichkeiten neu ist, erklärt es der Abschnitt Grundlagen: Wahrscheinlichkeit von Grund auf.
Nimm 200 Tests, die jeweils in einem von 200 Läufen zufällig scheitern, also :
Mit und scheitern rund 63 % aller Läufe ohne Grund. Jeder einzelne Test wirkt mit 99,5 % zuverlässig, und trotzdem ist die Sammlung öfter rot als grün.
Eine zweite, einfachere Formel sagt dir, wie viele zufällige Fehlschläge du pro Lauf erwarten musst:
Dabei ist die erwartete Zahl zufällig scheiternder Tests in einem Lauf, die Zahl der Tests und die Wahrscheinlichkeit eines zufälligen Fehlschlags je Test. Den Erwartungswert erklärt Grundlagen: Erwartungswert. Micco rechnet selbst so: Ein Projekt mit rund 1.000 Tests und einer Quote von 1,5 % hat , es werden also pro Freigabelauf voraussichtlich etwa 15 Tests scheitern10.
Das Diagramm ist mit der Formel berechnet, nicht gemessen. Egal welcher Linie du folgst, die Lehre ist dieselbe: Wackeligkeit, die in einem Test harmlos aussieht, wird in einer großen Sammlung zum Normalzustand.
Beispiel: die wackeligen Browsertests des Teehauses
Angenommen, 2 % der End to End Läufe im Teehaus scheitern zufällig, also , und es gibt davon. Dann ist . Fast jeder dritte Push wird rot, ohne dass etwas kaputt ist. Jana findet die Hauptursache: Ein Test prüft die Bestellbestätigung mit sleep 2 und schaut dann auf die Seite, und bei einem langsamen Lauf hat sich die Seite noch nicht aktualisiert. Sie ersetzt das Warten durch assert_text "Bestätigung gesendet", das wartet, bis der Text erscheint. Nach ein paar weiteren Korrekturen dieser Art sinkt die Quote auf 0,2 %, also , und die Wahrscheinlichkeit eines falschen roten Laufs fällt auf , etwa jeder 28. Push.
Erst Quarantäne, dann Reparatur: wohin mit einem flaky Test
Du kannst nicht jeden wackeligen Test in dem Moment reparieren, in dem du ihn siehst, und du darfst ihn auch nicht weiter den Build vergiften lassen. Die übliche Antwort hat vier Schritte.
- Bestätigen, dass er wackelt. Lass den Test auf demselben Code noch einmal laufen. Playwright erledigt das, wenn Wiederholungen eingeschaltet sind, und markiert einen Test, der zuerst scheiterte und bei der Wiederholung bestand, als "flaky", getrennt von "passed" und "failed"14.
- In Quarantäne stellen. Nimm ihn kurzzeitig aus der Prüfung, die eine Freigabe blockiert, mit einem Ticket und einem Namen daneben. Google macht das automatisch, wenn die Wackeligkeit eines Tests zu hoch wird: Das Werkzeug nimmt ihn aus dem kritischen Pfad und legt einen Fehlerbericht für die Entwicklung an10.
- Die Ursache beheben, nicht das Symptom. Schau zuerst auf die drei großen Ursachen aus der Studie aus Illinois: ein fehlendes Warten, Threads oder Jobs, die sich ein Rennen liefern, und Tests, die von der Reihenfolge oder von Daten abhängen, die ein anderer Test hinterlassen hat11.
- Zurückholen. Nimm den Test wieder in die Prüfung auf, sobald er viele Läufe in Folge bestanden hat. Ein Test in Quarantäne ohne Verantwortliche und ohne Frist ist ein gelöschter Test mit Zusatzschritten.
Dreh nicht einfach die automatischen Wiederholungen hoch, bis der Build grün ist. Wiederholungen verstecken wackelige Tests. Selbst Googles Bericht hält fest: Einen flaky Test erst nach drei Fehlschlägen in Folge als gescheitert zu werten, reduziert falsche Alarme, verleitet aber dazu, die Wackeligkeit der eigenen Tests zu ignorieren, und kann die Entdeckung eines echten Fehlers verzögern10.
Beispiel: ein wackeliger Test, von Anfang bis Ende
An einem Dienstag wird der Build des Teehauses rot: Der End to End Test "eine Abonnentin pausiert einen Monat" ist gescheitert. Jana startet ihn auf demselben Commit neu, er besteht, und der Bericht von Playwright markiert ihn als flaky. Sie markiert den Test als in Quarantäne, legt ein Ticket mit ihrem Namen und der Frist Freitag an, und die Freigabe läuft mit den übrigen 17 Browsertests plus allen Unit und Integrationstests weiter. Am Mittwoch lässt sie den Test 50 Mal hintereinander auf ihrem Rechner laufen und sieht 3 Fehlschläge. Jeder davon passiert, wenn der Test direkt nach "eine Kundin kündigt ihr Abo" läuft, der ein gekündigtes Abo in den gemeinsamen Testdaten hinterlässt. Das ist Abhängigkeit von der Reihenfolge. Sie lässt jeden Test seine eigene Abonnentin anlegen, statt eine gemeinsame zu nutzen, lässt ihn 200 Mal ohne Fehlschlag laufen, entfernt die Quarantäne und schließt das Ticket.
Wohin gehört dieser Test?
Mit all dem wird die Wahl der Ebene für einen neuen Test zu einer kurzen Reihe von Fragen. Die erste ist die wichtigste: Kann ein einfacher Aufruf einer Funktion oder eines Objekts das beweisen? Dann schreib einen Unit Test. Braucht es die Datenbank, den Mailversand, einen Job oder den Fake eines fremden Dienstes, schreib einen Integrationstest. Dann frag gesondert: Würde die Kundschaft eine Bestellung oder Geld verlieren, wenn das im Browser bricht? Nur dann verdient es einen Platz in einem End to End Ablauf.
Beispiel: drei neue Anforderungen, eingeordnet
Der Inhaber des Teehauses wünscht sich in einer Woche drei Änderungen. Jana schickt jede durch die Fragen.
- "Geschenkabos bekommen zur ersten Lieferung eine Teedose dazu." Ob eine Bestellung dafür in Frage kommt, ist eine Regel auf einfachen Werten: Ist es ein Geschenk, ist es die erste Lieferung? Unit Test. Würde die Kundschaft eine Bestellung verlieren, wenn die Dose fehlt? Nein. Kein Browsertest.
- "Drei Tage vor jeder Aboverlängerung eine Erinnerung schicken." Das braucht die Datenbank (welche Abos sich wann verlängern), einen Hintergrundjob und den Mailversand. Integrationstest, in dem die Zeit vorgestellt wird. Würde die Kundschaft im Browser Bestellung oder Geld verlieren? Es gibt hier gar keinen Browser. Kein Browsertest.
- "Kundschaft im Kleinwalsertal kann an der Kasse einen anderen Paketdienst wählen." Die Versandregel selbst bekommt Unit Tests. Das Speichern der Wahl an der Bestellung bekommt einen Integrationstest. Und weil eine kaputte Auswahl des Paketdienstes die Kundschaft am Bezahlen hindern könnte, erweitert Jana den bestehenden Checkout Ablauf um einen Schritt mit einer Adresse in Mittelberg, statt einen neuen End to End Test zu schreiben.
Drei Anforderungen, fünf oder sechs neue Unit und Integrationstests, ein erweiterter Browsertest, und die Sammlung behält die Form einer Pyramide.
Was du als Auftraggeber fragen solltest
Wenn du Software beauftragst, statt sie zu schreiben, musst du die Tests nicht lesen. Du kannst trotzdem vier Fragen stellen, die viel verraten:
- Wie viele Tests gibt es ungefähr auf jeder Ebene, und sieht die Form eher nach Pyramide oder nach Stanitzel aus?
- Wie lange dauert die ganze Sammlung, und läuft sie bei jeder Änderung?
- Wie oft scheitert der Build ohne echten Grund, und was passiert mit einem wackeligen Test?
- Welche Abläufe der Kundschaft sind von Ende zu Ende abgedeckt, und welche davon dürfen nie brechen?
Gute Entwicklerinnen und Entwickler beantworten alle vier in wenigen Minuten. Der Leitfaden zu TDD und BDD in Ruby on Rails geht auf der Rails Seite tiefer.
Fazit: viele schnelle Tests, wenige langsame, keinen, den du ignorierst
Teste jedes Verhalten auf der tiefsten Ebene, die es beweisen kann. Unit Tests beweisen die Regeln, schnell und genau, also schreibst du viele. Integrationstests beweisen, dass die Teile zusammenarbeiten, mit Fakes anstelle der Dienste, die dir nicht gehören. End to End Tests beweisen, dass ein Mensch die Abläufe schafft, mit denen du Geld verdienst, und weil sie langsam und anfällig sind, bleiben es wenige. Gib jeder Ebene ein Zeitbudget, damit die Sammlung schnell genug bleibt, um ständig zu laufen. Und behandle einen wackeligen Test als Fehler, denn die Rechnung ist gnadenlos: Ein bisschen Zufall in jedem Test ergibt eine Sammlung, der niemand mehr glaubt. Das nächste Kapitel nimmt sich den wichtigsten dieser Abläufe vor, den kritischen Pfad, und zeigt, wie du ihn findest, abbildest und absicherst.