Den Unhappy Path testen: Fehler, Timeouts und Ausfälle

Kurz gesagt

Niveau: Fortgeschritten

Die meisten Testsuiten beweisen nur den Happy Path. Eine Studie zu echten Ausfällen fand: 92 % der katastrophalen begannen mit einem Fehler, den die Software schon erkannt und dann schlecht behandelt hatte.

  • Schreib den Fehlerfall zuerst: Prüf die genaue Fehlerklasse und den Satz, den die Kundschaft liest.
  • Simuliere, was du nicht auslösen kannst: Netz durch Stubs ersetzen (WebMock), Testkarten des Anbieters, Uhr verstellen (travel_to), Abhängigkeiten Fehler werfen lassen.
  • Teste, dass Wiederholungen kommen und aufhören, und dass ein Doppelklick nur einmal abbucht.
  • Ein Timeout bei einer Zahlung ist unbekannt, nie gescheitert.
  • Ausgearbeitetes Beispiel: fünf Tests für den Checkout eines Teeshops.

Meine Tests sind grün, wenn alles funktioniert. Woher weiß ich, was passiert, wenn nicht? Dieses Kapitel beantwortet das mit echten Tests: abgelehnte Karten, Timeouts, doppelt abgeschickte Bestellungen, Bestand, der im falschen Moment ausgeht, und ein Mailserver, der weg ist, jeder Test geschrieben vor dem Code, der den Fall behandelt.

Deine Tests sind grün. Das beweist weniger, als du denkst.

Die meisten Testsuiten beantworten eine einzige Frage: Funktioniert die Software, wenn alles glattläuft? Die Kundin hat eine gültige Karte, der Zahlungsanbieter antwortet in 200 Millisekunden, der Tee ist auf Lager, der Mailserver ist wach. Diesen Weg durch den Code nennt man den Happy Path.

Der Unhappy Path ist alles andere. Die Karte wird abgelehnt. Der Anbieter braucht 40 Sekunden und sagt dann gar nichts. Jemand drückt zweimal auf Bezahlen, weil der Button zu hängen schien. Die letzte Dose Darjeeling ging an jemand anderen, während dieser Warenkorb über die Mittagspause offen stand. Der Mailserver ist wegen Wartung weg. Nichts davon ist exotisch. In einem Shop, der jeden Tag Zahlungen annimmt, passiert all das. Die Frage ist nur, ob die Software gesagt bekommen hat, was sie dann tun soll.

In diesem Kapitel geht es darum, genau das mit Tests zu beweisen, bevor es dir eine Kundin beweist. Es baut auf der Testschleife aus Kapitel eins auf und auf den Mustern zur Fehlerbehandlung aus Kapitel sechs. Kapitel sechs hat gezeigt, wie du Code schreibst, der mit Fehlern umgeht. Dieses Kapitel zeigt, wie du weißt, dass er es tut.

Die Beweislage ist ungewöhnlich klar. Ein Team der University of Toronto hat 198 echte, von Nutzern gemeldete Ausfälle in fünf weit verbreiteten verteilten Systemen untersucht, darunter Cassandra, HBase und Redis. Von den 48 Ausfällen, die den ganzen Dienst lahmlegten, gingen 92 % auf eine falsche Behandlung von Fehlern zurück, die die Software bereits erkannt und gemeldet hatte. Bei 58 % dieser katastrophalen Ausfälle hätte ein einfacher Test des Fehlerbehandlungscodes den Fehler leicht gefunden. Und 35 % liefen auf drei triviale Muster hinaus: ein Fehlerhandler, der leer war oder nur eine Logzeile schrieb, einer, der eine viel zu breite Fehlerklasse abfing und alles herunterfuhr, oder einer, in dem noch "TODO" stand1.

In einfachen Worten: Die Software hat das Problem kommen sehen. Jemand hat Code dafür geschrieben. Niemand hat diesen Code je ausgeführt. Das ist der Unhappy Path, und deshalb braucht er eigene Tests.

Beispiel: der eine Test, den Teekontor Hansen schon hat

Teekontor Hansen ist ein Onlineshop für Tee in Hamburg. Er verkauft losen Tee und Abos, nimmt Kartenzahlungen über einen Zahlungsanbieter an, hat Rabattcodes, führt einen Lagerbestand und verschickt Bestellmails. Die Entwicklerin, Jana, hat genau einen Checkout Test:

it "places an order" do
  stub_payment_succeeds
  order = checkout
  expect(order.status).to eq("paid")
end

Er ist grün, jedes Mal. Jetzt stell ihm fünf Fragen. Was passiert, wenn die Karte abgelehnt wird? Wenn der Anbieter nie antwortet? Wenn dieselbe Bestellung zweimal ankommt? Wenn der Bestand vor einer Minute ausverkauft war? Wenn die Bestätigungsmail nicht rausgeht? Zu keiner davon hat der Test eine Meinung. Er beweist, dass der Shop an einem guten Tag funktioniert, und nur an einem guten Tag. Am Ende dieses Kapitels hat Jana für jede dieser fünf Fragen einen Test, jeweils geschrieben vor dem Code, der sie beantwortet.

Seltene Fehler sind nicht selten, sobald du multiplizierst

Ein Fehler, der "fast nie" passiert, klingt nach etwas, das man ignorieren kann. Das Problem: fast nie, multipliziert mit einem vollen Jahr, ergibt eine Zahl, die du zählen kannst. Wie oft etwas im Schnitt schiefgeht, ist einfach die Zahl der Versuche mal die Wahrscheinlichkeit, dass ein einzelner Versuch schiefgeht (Grundlagen: Erwartungswert):

E=n⋅pE = n \cdot p

Dabei ist EE die erwartete Zahl an Fehlern im Zeitraum, nn die Zahl der Versuche in diesem Zeitraum (hier Kartenzahlungen) und pp die Wahrscheinlichkeit, dass ein einzelner Versuch genau auf diese Weise scheitert.

Dieselbe Rechnung gilt für jeden Unhappy Path: Ablehnungen, Timeouts, Doppelklicks, Rennen um den letzten Artikel. Jeder ist klein, und jeder wird, multipliziert, zu einer Handvoll echter Kundinnen und Kunden mit einem echten Problem.

Beispiel: zehn Timeouts im Jahr bei Teekontor Hansen

Die Zahlen sind für das Beispiel erfunden. Angenommen, Teekontor Hansen nimmt 20.000 Kartenzahlungen im Jahr an, und eine von 2.000 läuft zwischen Shop und Zahlungsanbieter in einen Timeout im Netz. Also n=20000n = 20000 und p=12000=0,0005p = \frac{1}{2000} = 0{,}0005.

E=20000⋅0,0005=10E = 20000 \cdot 0{,}0005 = 10

Also E=10E = 10. Zehnmal im Jahr drückt jemand auf Bezahlen, und der Shop weiß nicht, ob das Geld geflossen ist. Wurde der Code für diesen Moment nie getestet, bekommen diese zehn Menschen, was der Code eben gerade tut: vielleicht eine Fehlerseite, vielleicht eine zweite Abbuchung beim nächsten Versuch, vielleicht eine bezahlte Bestellung, die nie verschickt wird. Zehn ist nicht viel. Es sind zehn Bewertungen, zehn Supportmails und womöglich zehn Erstattungen, jedes Jahr, für eine Lage, die ein einziger Test geklärt hätte.

Schreib den Fehlerfall zuerst

Die Testschleife aus Kapitel eins funktioniert für Fehler genauso wie für Features. Du beschreibst den Fehler, den du erwartest, siehst den Test scheitern und schreibst dann gerade so viel Code, dass er grün wird. Der Unterschied liegt nur darin, was der Test prüft: nicht, dass ein Wert zurückkommt, sondern dass der richtige Fehler ausgelöst wird, mit der richtigen Meldung, und dass unterwegs nichts anderes verändert wurde.

Beide gängigen Testbibliotheken in Ruby können direkt sagen "das soll einen Fehler werfen". In Minitest heißt das assert_raises, und es gibt die Exception zurück, damit du ihre Meldung prüfen kannst2. In RSpec ist es der Matcher raise_error, der die Fehlerklasse nimmt und optional die Meldung oder ein Muster dafür3. Nenn immer die Klasse. Ein nacktes raise_error ohne Klasse ist bei jedem Fehler zufrieden, auch bei einem Tippfehler in deinem eigenen Code, und wird so aus genau dem falschen Grund grün.

Beispiel: ein Rabattcode, der aufgebraucht ist

Teekontor Hansen verteilt einen Code, WILLKOMMEN5, der 100 Mal eingelöst werden darf. Jana beginnt mit dem Fehlerfall, in Minitest:

class DiscountCodeTest < ActiveSupport::TestCase
  test "a code that has been used up is refused" do
    code = DiscountCode.new(code: "WILLKOMMEN5", percent_off: 5, max_uses: 100, uses: 100)

    error = assert_raises(DiscountCode::UsedUp) { code.apply_to(4_000) }

    assert_equal "WILLKOMMEN5 wurde schon so oft eingelöst wie erlaubt.", error.message
  end
end

Zeile für Zeile: Sie baut einen Code, der schon 100 von 100 Mal benutzt wurde. Sie lässt ihn auf einen Warenkorb von 4.000 Cent wirken, also 40 € (Geldbeträge in Cent ersparen Überraschungen beim Runden). assert_raises erwartet, dass dieser Aufruf DiscountCode::UsedUp auslöst, und gibt den Fehler zurück. Die letzte Zeile prüft die Meldung, denn genau dieser Text landet bei der Kundschaft.

Sie lässt ihn laufen. Er scheitert mit NameError: uninitialized constant DiscountCode::UsedUp. Rot, aber aus dem falschen Grund: Die Fehlerklasse gibt es noch gar nicht, der Test ist also nie bei seiner eigentlichen Frage angekommen. Sie ergänzt eine Zeile im Model, UsedUp = Class.new(StandardError), und startet ihn erneut. Jetzt scheitert er mit "DiscountCode::UsedUp expected but nothing was raised". Rot aus dem richtigen Grund. Erst jetzt schreibt sie die Regel:

class DiscountCode < ApplicationRecord
  UsedUp = Class.new(StandardError)

  def apply_to(subtotal_cents)
    raise UsedUp, "#{code} wurde schon so oft eingelöst wie erlaubt." if uses >= max_uses

    subtotal_cents - (subtotal_cents * percent_off / 100)
  end
end

Grün. Derselbe Test in RSpec hieße expect { code.apply_to(4_000) }.to raise_error(DiscountCode::UsedUp, /WILLKOMMEN5/). So oder so ist der Fehlerfall jetzt Teil der Spezifikation und kann bei einer späteren Änderung nicht still verschwinden.

Prüf, was die Kundschaft sieht, nicht nur, was der Code wirft

Eine Exception ist eine Nachricht deines Codes an deinen Code. Die Kundschaft sieht Stripe::CardError nie, und darf es auch nicht. Irgendwo zwischen Fehler und Bildschirm übersetzt der Shop ihn in Worte, mit denen ein Mensch etwas anfangen kann: was passiert ist, ob Geld geflossen ist und was als Nächstes zu tun ist. Diese Übersetzung ist ebenfalls Code und geht kaputt wie jeder andere. Ein Test des Unhappy Path ist erst vollständig, wenn er beide Enden prüft: den richtigen Fehler innen und den richtigen Satz außen, ohne dass Interna durchsickern.

Beispiel: die abgelehnte Karte, so wie die Kundin sie liest

Jana schreibt einen Request Spec. Er schickt eine echte HTTP Anfrage an den Checkout des Shops und liest die Seite, die zurückkommt. Der Zahlungsanbieter ist durch einen Stub ersetzt, den der nächste Abschnitt erklärt, und der antwortet mit "Karte abgelehnt".

RSpec.describe "Checkout", type: :request do
  it "tells the customer plainly when the card is declined" do
    stub_card_declined

    post checkout_path, params: { payment_method: "pm_test" }
    follow_redirect!

    expect(response.body).to include("Deine Karte wurde abgelehnt. Es wurde nichts abgebucht.")
    expect(response.body).not_to include("CardError")
  end
end

Die erste Erwartung prüft den Satz, den die Kundin braucht: was passiert ist, und die eine Tatsache, die einen panischen Anruf verhindert, nämlich dass kein Geld abgegangen ist. Die zweite Erwartung ist das Sicherheitsnetz. Lässt eine spätere Änderung den rohen Namen der Exception auf die Seite durch, wird dieser Test rot. Die Formulierung ist eine Designentscheidung, also kommt der genaue Satz von der Person, die für die Stimme des Shops verantwortlich ist, und der Test hält ihn fest.

Fehler simulieren, die du nicht auf Knopfdruck auslösen kannst

Du kannst den Zahlungsanbieter nicht bitten, um 10:00 Uhr für deinen Testlauf auszufallen. Du kannst die Uhr nicht auf Kommando Mitternacht schlagen lassen oder die Festplatte des Servers füllen. Der Kniff beim Testen des Unhappy Path ist deshalb Simulation: Du ersetzt die echte Welt für die Dauer eines Tests durch eine Version, die genau so scheitert, wie du es brauchst. Dafür gibt es vier Werkzeuge, und jedes passt zu einer anderen Art von Fehler.

Das Netz durch einen Stub ersetzen

Ein Stub ersetzt einen echten Aufruf über das Netz durch eine vorbereitete Antwort. In Ruby fängt die Bibliothek WebMock HTTP Anfragen der gängigen Clients ab und lässt dich bestimmen, was zurückkommt: eine normale Antwort, ein Fehlerstatus, eine ausgelöste Exception oder ein Timeout, mit to_return, to_raise und to_timeout4. Schalte echte Verbindungen im Testsetup mit WebMock.disable_net_connect!(allow_localhost: true) ab, dann scheitert jede Anfrage, die du zu stubben vergessen hast, laut. So erreicht ein Test nie aus Versehen einen echten Server.

Stubs sind schnell und wiederholbar, also laufen sie bei jedem Commit. Ihre Schwäche: Sie wissen nur, was du ihnen gesagt hast. Ändert der echte Anbieter seine Antworten, erzählt dein Stub weiter die alte Geschichte. Dafür ist das nächste Werkzeug da.

Beispiel: der Paketdienst antwortet nicht

Teekontor Hansen fragt im Warenkorb die API eines Paketdienstes nach dem Versandpreis. Antwortet der Paketdienst nicht, soll der Shop nicht einfrieren. Er soll seine Pauschale von 3,95 € zeigen und die Kundin weitermachen lassen.

RSpec.describe ShippingQuote do
  it "falls back to the flat rate when the courier does not answer" do
    stub_request(:get, %r{\Ahttps://api\.courier\.example/rates}).to_timeout

    quote = ShippingQuote.for(postcode: "20095", weight_grams: 250)

    expect(quote.price_cents).to eq(395)
    expect(quote).to be_fallback
  end
end

Die erste Zeile sagt WebMock, dass sich jeder GET Aufruf an die Preisadresse des Paketdienstes wie ein Server verhalten soll, der nie antwortet. Die zweite Zeile fragt nach einem Preis für ein Paket mit 250 Gramm an eine Hamburger Postleitzahl. Die Erwartungen halten fest, was Jana entschieden hat: die Pauschale, und eine Markierung, dass es eine Ausweichlösung ist, damit der Shop das protokollieren und die Seite "Standardversand" anzeigen kann. Erst der Test hat diese Entscheidung erzwungen. Vorher hatte niemand gesagt, was ein fehlender Paketdienst bedeutet.

Die Testkarten des Anbieters nutzen

Zahlungsanbieter wissen, dass alle Ablehnungen testen müssen, also veröffentlichen sie Testkarten, die absichtlich scheitern. Die Sandbox von Stripe dokumentiert zum Beispiel eine Karte, die immer abgelehnt wird (4000 0000 0000 0002, oder die PaymentMethod pm_card_visa_chargeDeclined), eine, die wegen fehlender Deckung abgelehnt wird (4000 0000 0000 9995), und eine, die als abgelaufen abgelehnt wird (4000 0000 0000 0069, oder pm_card_chargeDeclinedExpiredCard), neben der Karte, die immer funktioniert (4242 4242 4242 4242)5. Die Dokumentation listet außerdem, welche Ruby Exception jede Art von Fehler auslöst: Stripe::CardError für Zahlungsfehler, Stripe::APIConnectionError für Probleme im Netz und so weiter6.

Tests gegen die Sandbox sprechen über das Internet mit dem echten Anbieter, sind also langsamer und manchmal wackelig. Sie gehören in eine eigene Suite, die nachts oder vor einem Release läuft, nicht bei jedem Speichern. Ihre Aufgabe ist, den Tag zu erwischen, an dem deine Stubs und der echte Anbieter nicht mehr übereinstimmen. Eine Bibliothek wie VCR kann echte Antworten der Sandbox aufzeichnen und in späteren Läufen abspielen, was sie schnell und wiederholbar macht7. Mit einer Einschränkung: Eine Aufzeichnung ist eine Momentaufnahme. Nimm sie regelmäßig neu auf, sonst wird sie zu einem weiteren Stub mit einer alten Geschichte.

Beispiel: die nächtliche Prüfung in der Sandbox

RSpec.describe "Stripe sandbox declines", :sandbox do
  before { WebMock.allow_net_connect! }
  after  { WebMock.disable_net_connect!(allow_localhost: true) }

  %w[pm_card_visa_chargeDeclined pm_card_chargeDeclinedExpiredCard].each do |card|
    it "turns #{card} into a declined checkout" do
      expect { checkout(payment_method: card) }.to raise_error(Checkout::Declined)
    end
  end
end

Das Tag :sandbox erlaubt Jana, diese Datei aus dem normalen Lauf herauszunehmen (config.filter_run_excluding :sandbox in der RSpec Konfiguration) und sie jede Nacht für sich mit bundle exec rspec --tag sandbox zu starten. Die Zeilen mit before und after öffnen das Netz nur für diese Tests und schließen es danach wieder. Die Schleife führt dieselbe Prüfung für zwei der dokumentierten Testkarten aus: Jede muss als der eigene Fehler des Shops, Checkout::Declined, zurückkommen, nicht als rohe Exception des Anbieters und nicht als Erfolg.

Die Uhr verstellen

Alles, was vom Datum abhängt, scheitert an einer Grenze: ein Rabatt, der um Mitternacht endet, ein Abo, das am Monatsersten verlängert wird, eine Karte, die am Monatsende abläuft. Tests mit der echten Uhr sind heute grün und an irgendeinem späteren Tag ohne sichtbaren Grund rot. Rails löst das mit travel_to, das Time.now, Date.today und DateTime.now so ersetzt, dass der Test innerhalb eines Blocks genau im gewählten Moment lebt8.

Die Regel für die Wahl dieses Moments heißt Grenzwertanalyse: Teste den letzten Moment, der funktionieren soll, und den ersten, der es nicht mehr soll. Genau dort wohnen die Fehler, bei denen man sich um eins verzählt.

Beispiel: der Frühlingscode endet um Mitternacht

test "FRUEHLING10 works until the last second of 31 March" do
  code = DiscountCode.new(code: "FRUEHLING10", percent_off: 10, max_uses: 500, uses: 0,
                          expires_at: Time.zone.parse("2026-03-31 23:59:59"))

  travel_to Time.zone.parse("2026-03-31 23:59:59") do
    assert_equal 3_600, code.apply_to(4_000)
  end

  travel_to Time.zone.parse("2026-04-01 00:00:00") do
    assert_raises(DiscountCode::Expired) { code.apply_to(4_000) }
  end
end

Der erste Block setzt den Test eine Sekunde vor das Ende: 10 % auf 40 € müssen 36 € ergeben, also 3.600 Cent. Der zweite Block setzt ihn eine Sekunde danach, und derselbe Code muss abgelehnt werden. Zwei Momente, eine Sekunde auseinander, und die ganze Regel ist festgenagelt. Schreibt später jemand >=, wo > hingehört, merkt das dieser Test, bevor es eine Kundin merkt.

Die Abhängigkeit einen Fehler werfen lassen

Manche Fehler passieren gar nicht im Netz: Die Platte ist voll, eine Datei fehlt, eine Bibliothek wirft. Hier ist das einfachste Werkzeug ein Stub auf deinem eigenen Objekt, der genau die Exception wirft, die der echte Fehler werfen würde. In RSpec ist das allow(SomeClass).to receive(:method).and_raise(SomeError).

Beispiel: die Rechnung lässt sich nicht speichern

Nach der Zahlung schreibt Teekontor Hansen eine Rechnung als PDF in den Speicher. Ist die Platte voll, wirft Ruby Errno::ENOSPC. Janas Entscheidung: Die Bestellung bleibt bezahlt, die Rechnung wird als fehlgeschlagen markiert, damit sie neu erzeugt werden kann, und niemandes Geld hängt an einem PDF.

RSpec.describe GenerateInvoiceJob do
  it "keeps the order paid and flags the invoice when the disk is full" do
    order = Order.create!(status: "paid", email: "ada@example.com")
    allow(InvoicePdf).to receive(:write).and_raise(Errno::ENOSPC)

    GenerateInvoiceJob.perform_now(order)

    expect(order.reload.status).to eq("paid")
    expect(order.invoice_status).to eq("failed")
  end
end

Der Stub lässt den PDF Schreiber genau wie eine volle Platte reagieren. Der Job läuft. Die Erwartungen prüfen die zwei Dinge, auf die es ankommt: Die Bestellung wurde nicht angefasst, und der Fehler wurde dort festgehalten, wo ihn jemand sieht. Genau diese Art Handler fand die Studie aus Toronto in der Produktion scheitern: einer, der nur protokollierte oder zu viel abfing1. Jetzt wurde er wenigstens einmal ausgeführt.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

Wiederholungen testen: der zweite Versuch kommt, und der letzte hört auf

Kapitel sechs hat Wiederholungen erklärt: Ist ein Fehler vorübergehend, versuch es etwas später noch einmal. Eine Wiederholung ist Code für den Unhappy Path mit zwei Arten, schiefzugehen. Sie kommt nie, und aus einem kurzen Aussetzer wird eine verlorene Mail. Oder sie hört nie auf, und aus einem dauerhaften Problem wird eine Endlosschleife, von der niemand erfährt. Ein guter Test prüft beide Enden: dass ein Fehler einen weiteren Versuch einplant, und dass nach dem letzten Versuch ein Mensch Bescheid bekommt.

In Rails legen Hintergrundjobs das mit retry_on fest, und die Rails Guides halten fest, dass ein gescheiterter Job nicht wiederholt wird, solange du es nicht konfigurierst9. Das Gem rspec-rails prüft dann mit dem Matcher have_enqueued_job, ob ein Job wieder in die Warteschlange gestellt wurde10. Dafür braucht es den Testadapter für die Warteschlange (config.active_job.queue_adapter = :test in der Testumgebung).

Beispiel: die Bestellmail, die nicht rausgeht

class SendOrderConfirmationJob < ApplicationJob
  retry_on Net::OpenTimeout, Net::SMTPServerBusy, attempts: 5 do |job, _error|
    AdminMailer.confirmation_failed(job.arguments.first).deliver_later
  end

  def perform(order)
    OrderMailer.confirmation(order).deliver_now
  end
end

Der Job verschickt die Bestätigungsmail. Läuft der Mailserver in einen Timeout oder meldet er sich als beschäftigt, versucht Rails es später erneut, bis zu fünf Versuche insgesamt. Scheitert auch der fünfte, läuft der Block, und Jana bekommt eine eigene Mail mit der Bestellung, der die Bestätigung fehlt. Jetzt die Tests:

RSpec.describe SendOrderConfirmationJob do
  let(:order) { Order.create!(status: "paid", email: "ada@example.com") }

  before { allow(OrderMailer).to receive(:confirmation).and_raise(Net::OpenTimeout) }

  it "tries again later when the mail server does not answer" do
    expect { described_class.perform_now(order) }
      .to have_enqueued_job(described_class).with(order)
  end

  it "stops after five attempts and tells a person" do
    job = described_class.new(order)
    job.executions = 4

    expect { job.perform_now }.to have_enqueued_mail(AdminMailer, :confirmation_failed)
  end
end

Die Zeile mit before lässt jeden Versuch, die Mail zu bauen, in einen Timeout laufen, als wäre der Mailserver weg. Der erste Test führt den Job einmal aus und erwartet denselben Job für dieselbe Bestellung wieder in der Warteschlange. Der zweite Test tut so, als wären schon vier Versuche gescheitert, indem er executions auf 4 setzt, führt den fünften aus und erwartet statt einer weiteren Wiederholung die Warnmail. Zwei kurze Tests, und die Regel für Wiederholungen ist eine Tatsache statt einer Hoffnung.

Fehler gezielt einspeisen: absichtlich kaputt machen, in kleinen Dosen

Chaos Engineering ist die Disziplin, mit einem System zu experimentieren, um Vertrauen aufzubauen, dass es turbulente Bedingungen in der Produktion aushält11. Netflix hat die Idee mit Chaos Monkey bekannt gemacht, einem Werkzeug, das in der Produktion zufällig Serverinstanzen beendet, damit die Entwicklung Dienste baut, die das überstehen12. Zu den veröffentlichten Prinzipien gehören, eine Hypothese über das normale Verhalten aufzustellen, reale Ereignisse zu variieren und den Wirkungsradius klein zu halten11.

Ein Teeshop muss keine Server zufällig abschalten. Aber die Idee lässt sich wunderbar verkleinern. Fault Injection heißt, eine einzelne Abhängigkeit in einem kontrollierten Test absichtlich scheitern zu lassen und zu beobachten, was das ganze System tut. In einem Browsertest mit Playwright kannst du jede Anfrage der Seite abfangen und mit einem benannten Netzfehler wie timedout oder connectionrefused abbrechen, oder mit einem beliebigen Status beantworten13. So testest du den Unhappy Path im Frontend, ohne einen Server anzufassen.

Beispiel: die Bestandsprüfung läuft im Browser in einen Timeout

Die Warenkorbseite von Teekontor Hansen fragt die eigene API des Shops, ob alles noch auf Lager ist. Jana will wissen, was eine Kundin sieht, wenn dieser Aufruf in einen Timeout läuft.

import { test, expect } from '@playwright/test';

test('the basket explains itself when the stock check times out', async ({ page }) => {
  await page.route('**/api/stock/**', (route) => route.abort('timedout'));

  await page.goto('/warenkorb');

  await expect(page.getByRole('alert')).toHaveText(
    'Wir konnten den Bestand gerade nicht prüfen. Dein Warenkorb ist gespeichert, versuch es in einer Minute noch einmal.'
  );
  await expect(page.getByRole('button', { name: 'Zur Kasse' })).toBeEnabled();
});

page.route fängt jede Anfrage an die Bestands API ab und bricht sie als Timeout ab, derselbe Fehler, den ein langsames Netz verursachen würde. Dann öffnet der Test den Warenkorb und prüft zwei Dinge: einen Hinweis mit einem ruhigen, nützlichen Satz (gefunden über seine barrierefreie Rolle, was nebenbei beweist, dass ein Screenreader ihn vorliest), und dass der Button zur Kasse weiter funktioniert. Die zweite Prüfung ist Absicht. Der Bestand wird bei der Zahlung noch einmal richtig geprüft, wie Test vier weiter unten beweist, also darf eine gescheiterte Prüfung hier niemanden im Warenkorb festhalten.

Grenzwerte und Property Based Testing

Grenzwerte kennst du schon: Teste knapp innerhalb und knapp außerhalb jeder Grenze. Für einen Rabatt in Prozent sind die spannenden Eingaben 0, 1, 99, 100 und 101. Für eine Menge sind es 0, 1 und der Lagerbestand. Die meisten Fehler, bei denen man sich um eins verzählt, fangen schon diese wenigen Fälle.

Property Based Testing geht einen Schritt weiter. Statt Eingaben von Hand zu wählen, formulierst du eine Regel, die für jede Eingabe gelten muss, und die Bibliothek erzeugt Hunderte zufälliger Eingaben, um sie zu brechen. Die Idee stammt von QuickCheck, einem Werkzeug für Haskell, das Koen Claessen und John Hughes 2000 veröffentlicht haben14. In JavaScript und TypeScript macht die Bibliothek fast-check dasselbe, und wenn sie eine scheiternde Eingabe findet, schrumpft sie diese auf die kleinste Eingabe, die noch scheitert, damit der Fehlerbericht lesbar bleibt15.

Beispiel: ein Rabatt macht die Summe nie negativ

Das Frontend von Teekontor Hansen berechnet die Summe des Warenkorbs. Egal welcher Warenkorb und welcher Rabatt, zwei Dinge müssen immer stimmen: Die Summe ist nie kleiner als null und nie größer als die Zwischensumme.

import { test } from 'vitest';
import fc from 'fast-check';
import { basketTotal } from './basketTotal';

test('a discount never makes the total negative or larger', () => {
  const line = fc.record({
    priceCents: fc.integer({ min: 1, max: 10_000 }),
    quantity: fc.integer({ min: 1, max: 20 }),
  });

  fc.assert(
    fc.property(fc.array(line), fc.integer({ min: 0, max: 100 }), (lines, percentOff) => {
      const subtotal = lines.reduce((sum, l) => sum + l.priceCents * l.quantity, 0);
      const total = basketTotal(lines, percentOff);
      return total >= 0 && total <= subtotal;
    })
  );
});

line beschreibt eine zufällige Zeile im Warenkorb: einen Preis zwischen 1 Cent und 100 € und eine Menge zwischen 1 und 20. fc.array(line) baut daraus zufällige Warenkörbe, auch den leeren, den handgeschriebene Tests gern vergessen. Die Eigenschaft läuft für jeden erzeugten Warenkorb und jeden Rabatt von 0 % bis 100 % und gibt nur dann true zurück, wenn beide Regeln gelten. Lässt später jemand einen festen Gutschein über 5 € auf einen Warenkorb von 3 € zu, findet die Bibliothek einen Warenkorb, der ins Minus rutscht, und meldet den kleinsten, den sie finden kann.

Ausgearbeitetes Beispiel: fünf Tests für den Unhappy Path im Checkout von Teekontor Hansen

Jetzt kommt alles an der Stelle zusammen, die im Shop am meisten zählt: der kritische Pfad vom Druck auf Bezahlen bis zur bestätigten Bestellung. Jana schreibt fünf Tests, einen für jede Frage vom Anfang des Kapitels, jeden vor dem Code, der ihn grün macht.

Zuerst das gemeinsame Setup. Eine kleine Hilfsdatei hält die Stubs, damit sich jeder Test wie ein Satz liest:

# spec/support/stripe_stubs.rb
module StripeStubs
  PAYMENT_INTENTS = "https://api.stripe.com/v1/payment_intents"

  def stub_payment_succeeds
    stub_request(:post, PAYMENT_INTENTS).to_return(
      status: 200, body: { id: "pi_test", object: "payment_intent", status: "succeeded" }.to_json
    )
  end

  def stub_card_declined
    stub_request(:post, PAYMENT_INTENTS).to_return(
      status: 402, body: { error: { type: "card_error", code: "card_declined",
                                    message: "Your card was declined." } }.to_json
    )
  end
end

Beide Helfer ersetzen die Adresse, an der der Shop eine Zahlung anlegt. Der erste liefert eine erfolgreiche Zahlung. Der zweite liefert den Status 402 und den Fehlertext, den eine abgelehnte Karte erzeugt und den die Stripe Bibliothek in Stripe::CardError verwandelt6. Die Meldung des Anbieters bleibt englisch, sie ist für den Code bestimmt, nicht für die Kundschaft. Und der Kopf der Spec Datei:

RSpec.describe Checkout do
  include StripeStubs

  let(:darjeeling) { Product.create!(name: "Darjeeling 100g", price_cents: 650, stock: 5) }
  let(:basket) { Basket.create!.tap { |b| b.lines.create!(product: darjeeling, quantity: 2) } }

  def checkout(key: "order-7f3a")
    Checkout.new(basket:, payment_method: "pm_test", idempotency_key: key).call
  end

Fünf Dosen Darjeeling auf Lager, zwei im Warenkorb, und eine Methode checkout, die den ganzen Checkout mit einem Idempotenzschlüssel ausführt, einer eindeutigen Kennung für genau diesen einen Zahlungsversuch. Der Schlüssel wird in Test drei wichtig.

Test eins: Die Karte wird abgelehnt

  it "does not take the order when the card is declined" do
    stub_card_declined

    expect { checkout }.to raise_error(Checkout::Declined, "Your card was declined.")
    expect(darjeeling.reload.stock).to eq(5)
    expect(Order.last.status).to eq("declined")
  end

Der Anbieter sagt nein. Der Shop muss seinen eigenen Fehler Checkout::Declined auslösen, die zwei reservierten Dosen zurück ins Regal stellen (Bestand wieder 5) und den Versuch als abgelehnt festhalten, damit Jana ihn sieht. Ohne die Prüfung des Bestands würde eine Reihe abgelehnter Karten den Shop langsam ausverkauft aussehen lassen.

Test zwei: Der Anbieter antwortet nicht

  it "marks the payment as unknown when the provider does not answer" do
    stub_request(:post, StripeStubs::PAYMENT_INTENTS).to_timeout

    expect { checkout }.to raise_error(Checkout::PaymentUnknown)
    expect(Order.last.status).to eq("payment_unknown")
    expect(ConfirmPaymentJob).to have_been_enqueued.with(Order.last)
  end

Das ist der wichtigste der fünf Tests, und der, der den meisten Shops fehlt. Ein Timeout heißt nicht, dass die Zahlung gescheitert ist. Er heißt, dass der Shop es nicht weiß. Die Dokumentation von Stripe sagt selbst, dass das Ergebnis eines Verbindungsfehlers als unbestimmt zu behandeln ist, weder Erfolg noch Fehlschlag, und dass du es herausfindest, indem du mit demselben Idempotenzschlüssel wiederholst oder den Status der Zahlung abfragst6. Genau das verlangt der Test: keine Meldung "abgelehnt" an die Kundin, eine Bestellung mit unbekanntem Zahlungsstatus, deren Dosen reserviert bleiben, und ein Hintergrundjob, der herausfindet, was wirklich passiert ist. Die Kundin erfährt, dass die Zahlung gerade bestätigt wird und eine Mail folgt.

Test drei: Dieselbe Bestellung kommt zweimal

  it "charges once when the same order is submitted twice" do
    stub_payment_succeeds

    first = checkout(key: "order-7f3a")
    second = checkout(key: "order-7f3a")

    expect(second).to eq(first)
    expect(a_request(:post, StripeStubs::PAYMENT_INTENTS)
      .with(headers: { "Idempotency-Key" => "order-7f3a" })).to have_been_made.once
    expect(darjeeling.reload.stock).to eq(3)
  end

Die Kundin klickt doppelt auf Bezahlen, oder der Browser schickt das Formular erneut. Beide Anfragen tragen denselben Schlüssel, weil er einmal beim Laden der Checkout Seite entsteht. Der Test erwartet, dass der zweite Aufruf die erste Bestellung zurückgibt statt eine neue anzulegen, dass der Anbieter genau einmal gefragt wird (WebMock zählt die Anfragen4), dass der Schlüssel im Header Idempotency-Key mitgeht und dass nur zwei Dosen das Regal verlassen. Dieser Header ist der eigene Schutz des Anbieters: Stripe speichert das Ergebnis der ersten Anfrage mit einem Schlüssel und gibt jeder Wiederholung mit demselben Schlüssel dieses gespeicherte Ergebnis zurück, sodass selbst eine Wiederholung, die am Shop vorbeirutscht, nicht doppelt abbuchen kann16. Zwei Schichten, beide getestet.

Test vier: Der Tee war ausverkauft, während der Warenkorb wartete

  it "stops before charging when the stock ran out in the meantime" do
    stub_payment_succeeds
    darjeeling.update!(stock: 1) # jemand anderes hat über Mittag vier Dosen gekauft

    expect { checkout }.to raise_error(Checkout::OutOfStock, /Darjeeling/)
    expect(a_request(:post, StripeStubs::PAYMENT_INTENTS)).not_to have_been_made
    expect(Order.count).to eq(0)
  end

Der Warenkorb will zwei Dosen, eine ist noch da. Der Shop muss das bemerken, bevor er Geld nimmt, den ausverkauften Tee beim Namen nennen und keine halbe Bestellung zurücklassen. Die mittlere Erwartung ist die, die die Kundin schützt: Der Anbieter darf gar nicht erst gefragt werden. Erst abbuchen und dann erstatten kostet Gebühren, Vertrauen und eine Supportmail.

Test fünf: Der Maildienst ist weg

  it "keeps the order paid when the confirmation email cannot be sent yet" do
    stub_payment_succeeds

    order = checkout

    expect(order.status).to eq("paid")
    expect(SendOrderConfirmationJob).to have_been_enqueued.with(order)
  end
end

Der Checkout selbst spricht nie mit dem Mailserver. Er stellt den Mailjob in die Warteschlange und ist fertig. Genau dieses Design erzwingt der Test: Ein Ausfall beim Mailversand darf eine bezahlte Bestellung nie in eine Fehlerseite verwandeln. Wiederholung und Warnung des Jobs selbst decken schon die Tests im Abschnitt über Wiederholungen ab.

Der Code, der die fünf Tests grün macht

Jana hat die Tests einzeln geschrieben, jeden erst rot, dann grün. Der fertige Checkout, auf seine Form gekürzt, sieht so aus:

class Checkout
  Declined = Class.new(StandardError)
  PaymentUnknown = Class.new(StandardError)
  OutOfStock = Class.new(StandardError)

  def call
    existing = Order.find_by(idempotency_key: @key)
    return existing if existing

    order = reserve_stock_and_create_order # wirft OutOfStock, bevor abgebucht wird
    charge(order)
    order.update!(status: "paid")
    SendOrderConfirmationJob.perform_later(order)
    order
  end

  private

  def charge(order)
    @stripe.v1.payment_intents.create(payment_params(order), { idempotency_key: @key })
  rescue Stripe::CardError => e
    order.release_stock!
    order.update!(status: "declined")
    raise Declined, e.message
  rescue Stripe::APIConnectionError
    order.update!(status: "payment_unknown")
    ConfirmPaymentJob.perform_later(order)
    raise PaymentUnknown
  end
end

Jede Zeile beantwortet einen Test. Das frühe return beantwortet Test drei, zusammen mit einem eindeutigen Index auf idempotency_key in der Datenbank, damit zwei wirklich gleichzeitige Anfragen nicht beide eine Bestellung anlegen können. Die Reservierung des Bestands, die jede Produktzeile sperrt, während sie den Bestand prüft und verringert, beantwortet Test vier. Die zwei rescue Klauseln beantworten Test eins und zwei, jede fängt genau eine Fehlerklasse und nichts Breiteres, also genau der Fehler, den die Studie aus Toronto hinter so vielen Ausfällen fand1. Der Job in den letzten Zeilen beantwortet Test fünf.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

Eine Checkliste für den Unhappy Path in jedem Checkout

Jeder Shop ist anders, aber die Fehler an der Kasse wiederholen sich. Bevor ein Checkout als fertig gilt, gehört zu jedem dieser Punkte ein Test, oder ein schriftlich vereinbarter Grund, warum es keinen gibt:

  • Die Karte wird abgelehnt, für jeden Ablehnungsgrund, den der Shop anders formuliert.
  • Der Zahlungsanbieter läuft in einen Timeout, oder die Verbindung reißt ab, nachdem die Anfrage raus war.
  • Der Anbieter meldet einen Serverfehler.
  • Dieselbe Zahlungsanfrage kommt zweimal: Doppelklick, erneut gesendetes Formular, eine Wiederholung.
  • Der Bestand geht zwischen Warenkorb und Zahlung aus.
  • Ein Rabattcode ist abgelaufen, aufgebraucht oder für diesen Warenkorb nicht gültig.
  • Die Summe ist null, oder ein Rabatt würde sie unter null drücken.
  • Die Sitzung der Kundin läuft mittendrin ab.
  • Die Bestätigungsmail lässt sich nicht verschicken.
  • Rechnung oder Beleg lassen sich nicht erzeugen oder speichern.
  • Ein Webhook des Anbieters kommt zu spät, doppelt oder bevor die Bestellung existiert.
  • Eine externe Abfrage (Paketdienst, Steuer, Adresse) ist langsam oder weg.

Jede Zeile ist genauso eine Frage an das Geschäft wie an den Code. Was soll die Kundin lesen? Geht es um Geld? Wer muss es erfahren? Im Test wird die Antwort dauerhaft festgeschrieben.

Beispiel: Jana geht die Checkliste durch

Jana geht die Liste für Teekontor Hansen durch. Die fünf Tests oben decken die Zeilen eins, zwei, vier, fünf und neun ab. Der Stub für den Paketdienst und der Playwright Test decken Zeile zwölf ab. Zwei Zeilen haben noch keinen Test. Eine Sitzung, die auf der Zahlungsseite abläuft, zeigt derzeit eine allgemeine Fehlerseite. Also schreibt sie dafür einen scheiternden Request Spec und stimmt den Wortlaut mit dem Inhaber ab: "Deine Sitzung ist abgelaufen, dein Warenkorb ist aber gespeichert." Und der Webhook des Anbieters kann ankommen, bevor der Shop die Bestellung gespeichert hat, wodurch der Shop eine echte Zahlung übersehen würde. Der liegt auf dem kritischen Pfad, also kommt er zuerst. Ein Nachmittag, zwei neue rote Tests, und zwei Fehler, die bei der Kundschaft gelandet wären, werden jetzt mit Absicht behandelt.

Fazit

Eine Suite, die nur den Happy Path testet, sagt dir, dass die Software funktioniert, wenn nichts schiefgeht. Das ist genau der Tag, an dem du es nicht wissen musstest. Die Fehler, die Geld kosten, sind die erwartbaren: Ablehnungen, Timeouts, Doppelklicks, Rennen um den letzten Artikel und Ausfälle. Forschung zu echten Ausfällen in der Produktion zeigt, dass die meisten katastrophalen mit einem Fehler beginnen, den die Software schon erkannt und dann schlecht behandelt hat, in Code, den einfache Tests ausgeführt hätten1.

Also schreib den Test für den Unhappy Path zuerst, genau wie jeden anderen: Benenn den Fehler, sieh ihn aus dem richtigen Grund scheitern, dann mach ihn grün. Simuliere, was du nicht auslösen kannst: Ersetz das Netz durch Stubs, nutze die Testkarten des Anbieters, verstell die Uhr, lass Abhängigkeiten Fehler werfen. Teste, dass Wiederholungen kommen und dass sie aufhören. Prüf beides, den Fehler innen und den Satz außen. Und behandle einen Timeout bei einer Zahlung als unbekannt, nie als gescheitert.

Ich arbeite testgetrieben, und bei einem Checkout gehören die Fehler dazu: Der kritische Pfad ist erst abgesichert, wenn auch seine unglücklichen Abzweigungen getestet sind. Wenn du wissen willst, welche dieser zwölf Prüfungen dein eigener Shop heute bestehen würde, ist das eine gute erste Arbeitsstunde. Das nächste Kapitel wendet sich den Werkzeugen zu: wie du einen KI Assistenten zum testgetriebenen Arbeiten bringst, jedes Mal, für das ganze Projekt.

Wenn du wissen willst, was dein Checkout an seinem schlechtesten Tag tut, buch den kostenlosen Workshop: Wir gehen deinen kritischen Pfad gemeinsam mit der Checkliste für den Unhappy Path durch, und die ersten zwei Wochen Arbeit gehen auf mich.

Quellen

  1. 1.

    Ding Yuan, Yu Luo, Xin Zhuang, Guilherme Renna Rodrigues, Xu Zhao, Yongle Zhang, Pranay U. Jain und Michael Stumm, Simple testing can prevent most critical failures: an analysis of production failures in distributed data intensive systems, 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI), 2014, https://www.usenix.org/conference/osdi14/technical-sessions/presentation/yuan

  2. 2.

    Minitest, Dokumentation zu Minitest::Assertions (assert_raises), seattlerb, https://docs.seattlerb.org/minitest/Minitest/Assertions.html

  3. 3.

    RSpec, Matcher raise_error, Dokumentation zu rspec-expectations 3.13, https://rspec.info/features/3-13/rspec-expectations/built-in-matchers/raise-error/

  4. 4.

    Bartosz Blimke und Mitwirkende, WebMock: library for stubbing and setting expectations on HTTP requests in Ruby, README, GitHub, https://github.com/bblimke/webmock

  5. 5.

    Stripe, Testing: Testkartennummern und abgelehnte Zahlungen, Stripe Dokumentation, https://docs.stripe.com/testing

  6. 6.

    Stripe, Error handling (Ruby): Fehlertypen, Zahlungsfehler und Verbindungsfehler, Stripe Dokumentation, https://docs.stripe.com/error-handling?lang=ruby

  7. 7.

    VCR Mitwirkende, VCR: record your test suite's HTTP interactions and replay them, README, GitHub, https://github.com/vcr/vcr

  8. 8.

    Ruby on Rails, ActiveSupport::Testing::TimeHelpers (travel_to, freeze_time, travel_back), Rails API Dokumentation, https://api.rubyonrails.org/classes/ActiveSupport/Testing/TimeHelpers.html

  9. 9.

    Ruby on Rails, Active Job basics: Jobs wiederholen oder verwerfen, Rails Guides, https://guides.rubyonrails.org/active_job_basics.html

  10. 10.

    RSpec, Matcher have_enqueued_job, Dokumentation zu rspec-rails 7.1, https://rspec.info/features/7-1/rspec-rails/matchers/have-enqueued-job-matcher/

  11. 11.

    Principles of Chaos Engineering, principlesofchaos.org, zuletzt aktualisiert im März 2019, https://principlesofchaos.org/

  12. 12.

    Netflix, Dokumentation zu Chaos Monkey, GitHub Pages, https://netflix.github.io/chaosmonkey/

  13. 13.

    Microsoft, Playwright: class Route (route.abort und seine Fehlercodes), Playwright Dokumentation, https://playwright.dev/docs/api/class-route

  14. 14.

    Koen Claessen und John Hughes, QuickCheck: a lightweight tool for random testing of Haskell programs, Proceedings of the ACM SIGPLAN International Conference on Functional Programming (ICFP), 2000, https://www.cs.tufts.edu/~nr/cs257/archive/john-hughes/quick.pdf

  15. 15.

    fast-check, Introduction: property based testing für JavaScript und TypeScript, fast-check Dokumentation, https://fast-check.dev/docs/introduction/

  16. 16.

    Stripe, Idempotent requests, Stripe API Referenz, https://docs.stripe.com/api/idempotent_requests