Was ist Smoke Testing in der Softwareentwicklung? Es ist der erste schnelle Blick auf einen frischen Build: eine Handvoll Prüfungen, die eine einzige Frage beantworten: „Ist dieser Build stabil genug, um ihn überhaupt zu testen?“ Wenn die Anwendung nicht startet, die Login-Seite einen Fehler wirft oder der Checkout nie abschließt, hat es keinen Sinn, eine zweistündige Regressionssuite laufen zu lassen. Der Smoke Test erkennt das in wenigen Minuten und schickt den Build direkt zurück an die Entwickler.
Smoke Tests sind ein kleiner, aber tragender Bestandteil jedes ernsthaften Setups für Softwaretest-Dienstleistungen. Sie liegen zwischen den Unit Tests, für die die Entwickler verantwortlich sind, und den langsameren Funktions-, Regressions- und End-to-End-Suiten, und sie bilden das Gate, das entscheidet, ob diese langsameren Suiten überhaupt laufen. Teams, die dieses Gate auslassen, entdecken kaputte Builds meist auf die teure Art: nachdem Tester oder Kunden bereits Zeit damit verloren haben.
Dieser Leitfaden behandelt die Definition, die Herkunft des Begriffs, die Unterschiede zwischen Smoke Test, Build Verification Test, Sanity Test und Regressionstest, den richtigen Zeitpunkt, einen Ablauf in Schritten, eine Beispiel-Checkliste, die Einrichtung in CI/CD mit einem Pipeline-Beispiel, Tools für 2026, Vorteile und Grenzen sowie die Best Practices, die eine Smoke-Suite schnell und vertrauenswürdig halten.
Was ist Smoke Testing in der Softwareentwicklung?
Smoke Testing ist eine flache, aber breite Prüfung eines neuen Software-Builds, die verifiziert, dass seine wichtigsten Funktionen arbeiten, damit das Team entscheiden kann, ob es den Build für weitere Tests annimmt oder ablehnt. Es versucht nicht, jeden Fehler zu finden. Es sucht die Fehler, die jeden weiteren Test sinnlos machen.
Das ISTQB-Glossar, das weltweit von Softwaretestern genutzte Referenzvokabular, definiert einen Smoke Test als „a test suite that covers the main functionality of a component or system to determine whether it works properly before planned testing begins“ (sinngemäß: eine Testsuite, die die Hauptfunktionalität einer Komponente oder eines Systems abdeckt, um vor Beginn der geplanten Tests festzustellen, ob sie ordnungsgemäß funktioniert). Drei Gedanken aus dieser Definition sind in der Praxis entscheidend:
- Nur die Hauptfunktionalität. Ein Smoke Test deckt die kritischen Pfade ab, etwa den App-Start, die Anmeldung, das Laden des Hauptbildschirms und den Abschluss der Kerntransaktion. Randfälle kommen später.
- Breite vor Tiefe. Er berührt viele Bereiche des Systems oberflächlich, statt einen Bereich gründlich zu untersuchen.
- Vor den geplanten Tests. Er läuft zuerst, als Eingangskriterium. Ein fehlgeschlagener Smoke Test stoppt die Pipeline, ein bestandener öffnet die Tür für Funktions-, Regressions- und Performancetests.
Das Ergebnis eines Smoke Tests ist binär: Der Build „besteht den Smoke“ und geht weiter, oder er „fällt durch“ und geht zurück in die Entwicklung. Genau dieses einfache Ergebnis macht Smoke Tests so leicht automatisierbar und so nützlich als Gate.
Was ist ein Smoke Test in der Softwareentwicklung, einfach erklärt?
Einfach gesagt ist ein Smoke Test in der Softwareentwicklung ein schneller Gesundheitscheck eines neuen Builds. Denken Sie an einen Kfz-Mechaniker, der den Schlüssel dreht und prüft, ob der Motor anspringt, die Lichter angehen und die Bremsen reagieren, bevor er das Auto für eine vollständige Inspektion einplant. Niemand inspiziert ein Auto komplett, das nicht anspringt, und ebenso sollte niemand einen vollen Testzyklus auf einem Build fahren, der nicht startet.
Woher stammt der Begriff „Smoke Test“?
Der Begriff stammt aus der Hardware und dem Installateurhandwerk, lange vor der Software. Elektronikingenieure schalteten eine neu bestückte Platine zum ersten Mal ein und achteten auf Rauch: Kein Rauch bedeutete, dass die Platine zumindest sicher genug für richtige Tests war. Installateure pumpten harmlosen Rauch durch ein neues Rohrsystem, um zu sehen, wo er austrat.
Die Software übernahm die Idee in den 1990er-Jahren. Steve McConnells Artikel „Daily Build and Smoke Test“, erschienen im Juli 1996 in IEEE Software, beschrieb sie als „a common practice at Microsoft and some other shrink-wrap software companies“ (eine gängige Praxis bei Microsoft und einigen anderen Herstellern von Standardsoftware). In diesem Prozess wurde das gesamte Produkt jeden Tag kompiliert und anschließend einer relativ einfachen Prüfung unterzogen, ob es beim Ausführen „raucht“. McConnell nannte das Projekt Windows NT 3.0 als Beispiel: rund 5,6 Millionen Codezeilen in 40.000 Quelldateien, bei denen ein vollständiger Build bis zu 19 Stunden dauern konnte, und trotzdem führte ein vierköpfiges Build-Team den täglichen Build samt Smoke Test durch.
Das Prinzip hat sich seitdem nicht verändert. Verändert hat sich die Geschwindigkeit: Eine Pipeline im Jahr 2026 baut und smoke-testet eine Webanwendung in Minuten, bei jedem Merge, statt einmal pro Nacht.
Smoke Testing vs. Build Verification Testing: Ist das dasselbe?
Ja, in den meisten Teams bedeuten Smoke Testing und Build Verification Testing (BVT) dasselbe: eine Reihe von Prüfungen, die entscheidet, ob ein neuer Build gut genug zum Testen ist. Der einzige Unterschied liegt in der Betonung. „BVT“ unterstreicht, dass die Prüfung automatisiert ist und bei jedem Build läuft, „Smoke Test“ ist der breitere Alltagsbegriff.
Das ISTQB-Glossar definiert einen Build Verification Test als „an automated test that validates the integrity of each new build and verifies its key/core functionality, stability, and testability“ (sinngemäß: ein automatisierter Test, der die Integrität jedes neuen Builds validiert und seine Kernfunktionalität, Stabilität und Testbarkeit verifiziert). Vergleicht man das mit der obigen Smoke-Test-Definition, ist die Überschneidung offensichtlich. Weitere Bezeichnungen für dieselbe Idee sind Intake Test, Confidence Test und Build Acceptance Test.
Warum Sanity Testing manchmal als Smoke Test bezeichnet wird
Die Terminologie unterscheidet sich je nach Quelle, und das verwirrt viele Teams. Das ISTQB-Glossar führt Sanity Test, Intake Test und Confidence Test als Synonyme für Smoke Test. Die meisten Praktiker und Tool-Anbieter verwenden „Sanity Test“ jedoch für etwas Engeres: eine schnelle Prüfung eines bestimmten Fixes oder Features nach einer kleinen Änderung. Dieser Leitfaden folgt dem Sprachgebrauch der Praxis und vergleicht beide weiter unten im Detail. Welche Begriffe Ihr Team auch wählt: Legen Sie sie in Ihrer Teststrategie fest, damit „der Smoke ist fehlgeschlagen“ für alle dasselbe bedeutet.
Warum ist Smoke Testing wichtig?
Smoke Testing ist wichtig, weil es kaputte Builds im günstigsten möglichen Moment stoppt, bevor Tester, Staging-Umgebungen und Kunden Zeit darauf verwenden. Eine fünfminütige Prüfung, die einen fehlerhaften Build ablehnt, kann einem QA-Team einen ganzen Tag Fehlersuche und einem Release-Team einen Notfall-Rollback ersparen.
Die Kosten spät entdeckter Fehler sind gut belegt. Der Planning Report 02-3 des NIST (2002) schätzte, dass eine unzureichende Infrastruktur für Softwaretests die US-Wirtschaft jährlich rund 59,5 Milliarden US-Dollar kostete, wovon sich etwa 22,2 Milliarden US-Dollar durch früheres und besseres Testen vermeiden ließen. Smoke Tests ersetzen kein gründliches Testen, aber sie gehören zu den günstigsten Wegen, die Fehlererkennung nach vorn zu verlagern.
Im Arbeitsalltag bringt eine zuverlässige Smoke-Suite einem Team:
- Ein klares Go- oder No-Go-Signal. Niemand diskutiert, ob ein Build testbar ist, das Gate entscheidet.
- Geschützte QA-Zeit. Tester beginnen jeden Zyklus mit einem Build, der nachweislich startet und seinen Kernablauf abschließt.
- Schnelleres Feedback an die Entwickler. Ein fehlerhafter Merge wird innerhalb von Minuten gemeldet, solange die Änderung noch frisch ist.
- Sicherere Deployments. Smoke-Checks nach dem Deployment fangen Konfigurations- und Umgebungsfehler ab, die in Unit Tests nie auftauchen.
- Eine sichtbare Qualitäts-Baseline. Die Smoke-Erfolgsquote im Zeitverlauf zeigt, ob der Hauptzweig stabiler oder instabiler wird.
Zugleich ist es eine direkte Anwendung des Shift-Left-Ansatzes: die wichtigsten Prüfungen so früh und so oft wie möglich ausführen.
Wann sollten Sie Smoke Tests durchführen?
Führen Sie einen Smoke Test immer dann durch, wenn sich die Software so ändert, dass ihr Grundbetrieb gefährdet sein könnte: bei jedem neuen Build, vor jedem geplanten Testzyklus und direkt nach jedem Deployment. In einer CI/CD-Pipeline bedeutet das meist mehrmals täglich. Typische Auslöser sind:
- Ein neuer Build entsteht, ob durch einen Merge in den Hauptzweig oder als Nightly Build.
- Vor Beginn von Funktions- oder Regressionstests, als Eingangskriterium für den QA-Zyklus.
- Nach dem Deployment in eine Test- oder Staging-Umgebung, um zu bestätigen, dass Umgebung, Konfiguration und Daten korrekt verbunden sind.
- Unmittelbar nach einem Produktiv-Release, als Post-Deployment-Check der kritischen Pfade im Live-Betrieb.
- Nach Infrastrukturänderungen, etwa einem Datenbank-Upgrade, einer neuen Cloud-Region, einer Zertifikatsrotation oder einem Abhängigkeits-Update.
- Nach einem Hotfix, um zu bestätigen, dass der Fix weder den Start noch den Kernablauf beschädigt hat.
Der Staging-Schritt verdient besondere Aufmerksamkeit: Ein Build kann auf dem Rechner eines Entwicklers jeden Test bestehen und trotzdem in einer Umgebung mit anderen Secrets, Feature Flags oder Daten scheitern. Unser Leitfaden zu Staging in der Softwareentwicklung erklärt, wie Sie diese Umgebung nah genug an der Produktion halten, damit Smoke-Ergebnisse aussagekräftig sind.
Wer führt Smoke Testing durch?
Smoke Testing liegt meist in der Verantwortung der QA- oder Testautomatisierungs-Engineers, die die Suite entwerfen. In modernen Teams läuft sie jedoch automatisch, und das ganze Team handelt nach dem Ergebnis. Wer sie tatsächlich ausführt, hängt vom Reifegrad des Teams ab:
- QA-Engineers wählen die kritischen Pfade aus, schreiben die Smoke-Testfälle und halten die Suite gesund.
- Entwickler führen die Suite vor dem Push lokal aus und beheben einen fehlgeschlagenen Smoke sofort, weil er alle blockiert.
- DevOps- oder Platform-Engineers binden die Suite in die CI/CD-Pipeline und die Post-Deployment-Checks ein.
- Release-Manager behandeln einen bestandenen Smoke als Pflichtbedingung für die Freigabe eines Builds.
In kleinen Teams ohne eigene Tester übernehmen die Entwickler den gesamten Prozess. Das funktioniert, solange jemand ausdrücklich dafür verantwortlich ist, die Suite kurz und zuverlässig zu halten.
Wie Sie einen Smoke Test durchführen: 6 Schritte
Um einen Smoke Test durchzuführen, bestimmen Sie die wenigen Funktionen, ohne die das Produkt nicht leben kann, machen daraus kurze, wiederholbare Testfälle, führen sie bei jedem neuen Build in einer produktionsnahen Umgebung aus und nehmen den Build anhand eines einzigen Bestanden- oder Durchgefallen-Ergebnisses an oder lehnen ihn ab. Die folgenden Schritte funktionieren für Web-, Mobile- und API-Produkte.
- Kritische Pfade bestimmen. Listen Sie die Abläufe auf, deren Ausfall das Produkt unbrauchbar machen würde: Start, Anmeldung, Hauptbildschirm, die Kerntransaktion (Checkout, Buchung, Zahlung, Upload) und jede Integration, von der das Geschäft abhängt.
- Kurze, unabhängige Testfälle schreiben. Ein Test pro kritischer Prüfung, jeder eigenständig lauffähig mit bekannten Testdaten. Halten Sie die Schritte knapp und die erwarteten Ergebnisse eindeutig.
- Umgebung und Daten vorbereiten. Nutzen Sie eine stabile, produktionsnahe Umgebung mit vorab angelegten Konten und Testzahlungsmitteln. Smoke Tests, die von geteilten, sich ändernden Daten abhängen, werden schnell flaky.
- Die Suite auf dem neuen Build ausführen. Lösen Sie sie automatisch aus der Pipeline aus, oder arbeiten Sie die Checkliste bei sehr frühen Produkten von Hand ab.
- Eine Go- oder No-Go-Entscheidung treffen. Jeder Fehlschlag führt zur Ablehnung des Builds. Kein „bestanden mit Ausnahmen“: Wenn eine Prüfung nicht kritisch ist, gehört sie nicht in die Smoke-Suite.
- Melden und beheben. Schicken Sie den Fehler samt Logs und Screenshots an die Entwickler, die die Änderung vorgenommen haben, korrigieren Sie den Build und führen Sie den Smoke erneut aus, bevor andere Tests starten.
Was gehört in eine Smoke-Test-Suite? Eine Beispiel-Checkliste
Eine gute Smoke-Test-Suite enthält nur die Prüfungen, deren Fehlschlag weitere Tests sinnlos machen würde, typischerweise zwischen 5 und 30 Testfälle, die in wenigen Minuten durchlaufen. Die genaue Liste hängt vom Produkt ab, doch die meisten Suiten decken Start, Authentifizierung, Navigation, die Kerntransaktion und zentrale Integrationen ab.
Smoke-Test-Beispiel: eine E-Commerce-Webanwendung
Die folgende Tabelle zeigt eine realistische Smoke-Test-Checkliste für einen Onlineshop. Jede Zeile ist eine einzelne Prüfung mit einer klaren Bestehensbedingung.
| # | Prüfung | Bestehensbedingung |
|---|---|---|
| 1 | Startseite lädt | HTTP 200, Hauptnavigation und Produktraster sichtbar |
| 2 | Nutzer kann sich anmelden | Testkonto meldet sich an und sieht seinen Kontonamen |
| 3 | Suche liefert Ergebnisse | Ein bekanntes Produkt erscheint für eine bekannte Suchanfrage |
| 4 | Produktseite öffnet sich | Preis, Bilder und Button „In den Warenkorb“ werden angezeigt |
| 5 | Warenkorb funktioniert | Artikel wird hinzugefügt und die Warenkorbsumme aktualisiert |
| 6 | Checkout wird abgeschlossen | Testkartenzahlung gelingt in der Sandbox, Bestellnummer wird angezeigt |
| 7 | Bestellbestätigung wird versendet | Bestätigungs-Event oder E-Mail erreicht das Test-Postfach |
| 8 | Health-Endpoint ist grün | API, Datenbank und Zahlungsanbieter melden einen fehlerfreien Zustand |
Achten Sie darauf, was fehlt: Randfälle bei Rabatten, Regeln zur Adressvalidierung, sämtliche Zahlungsarten, Browserkompatibilität. Das gehört in Funktions- und Regressionssuiten. Der Smoke Test beweist nur, dass der Shop eine Bestellung annehmen kann.
Smoke-Test-Beispiele für Mobile Apps und APIs
Bei einer Mobile App prüft eine Smoke-Suite typischerweise, dass sich die App installieren und ohne Absturz starten lässt, der Onboarding- oder Login-Bildschirm erscheint, sich ein Nutzer anmelden kann, der Startbildschirm Daten aus dem Backend lädt und die Registrierung für Push-Benachrichtigungen gelingt. Bei einer API prüft sie, dass der Dienst startet, der Health-Endpoint antwortet, die Authentifizierung ein Token zurückgibt und je ein Lese- und ein Schreibaufruf auf die Hauptressource mit den erwarteten Statuscodes und der erwarteten Antwortstruktur gelingen.
Arten von Smoke Testing: manuell, automatisiert und hybrid
Smoke Testing kann manuell, automatisiert oder eine Mischung aus beidem sein. Automatisierte Smoke Tests sind der Standard für jedes Produkt mit CI/CD-Pipeline, während manuelle Smoke-Checks bei sehr frühen Produkten sowie für visuelle oder gerätespezifische Prüfungen, die sich schwer automatisieren lassen, weiterhin sinnvoll sind.
| Art | Funktionsweise | Am besten geeignet für | Größter Nachteil |
|---|---|---|---|
| Manuell | Ein Tester arbeitet bei jedem Build eine kurze schriftliche Checkliste ab | Prototypen, MVPs, seltene Releases | Langsam, uneinheitlich, skaliert nicht auf viele Builds pro Tag |
| Automatisiert | Skripte führen die Prüfungen bei jedem Build aus der CI/CD-Pipeline aus | Produkte mit häufigen Merges und Deployments | Erfordert Anfangsaufwand und laufende Wartung |
| Hybrid | Automatisierte Kernprüfungen plus einige manuelle Blicke auf Darstellung oder Geräte | Mobile Apps, UI-lastige Produkte | Der manuelle Teil fällt unter Termindruck leicht stillschweigend weg |
Smoke Testing auf verschiedenen Teststufen
Smoke Tests sind nicht auf das Gesamtsystem beschränkt. Teams führen Smoke-Checks oft auf mehreren Stufen aus: Ein Integrations-Smoke bestätigt, dass Dienste starten und miteinander kommunizieren können, ein System-Smoke bestätigt, dass kritische End-to-End-Abläufe in einer bereitgestellten Umgebung funktionieren, und ein Abnahme-Smoke bestätigt, dass ein Release Candidate für Fachanwender bereit ist. Unit Tests laufen ohnehin bei jeder Änderung, deshalb werden sie selten als Smoke Tests bezeichnet, obwohl eine fehlschlagende Unit-Stufe die Pipeline auf dieselbe Weise blockiert. Wie Unit Tests ins Gesamtbild passen, erklärt unser Beitrag zu Unit Testing in der Softwareentwicklung.
Smoke Testing vs. Sanity Testing vs. Regressionstest
Smoke Testing prüft, ob ein neuer Build überhaupt stabil genug zum Testen ist, Sanity Testing prüft, ob ein bestimmter Fix oder eine kleine Änderung wie beabsichtigt funktioniert, und Regressionstests prüfen, ob bestehende Funktionen nach einer Änderung weiterhin arbeiten. In dieser Reihenfolge nimmt die Tiefe zu: Smoke ist am breitesten und flachsten, Regression am tiefsten und langsamsten.
| Aspekt | Smoke Testing | Sanity Testing | Regressionstest |
|---|---|---|---|
| Beantwortete Frage | Ist dieser Build testbar? | Funktioniert dieser Fix oder diese Änderung? | Ist sonst etwas kaputtgegangen? |
| Umfang | Breit und flach, alle kritischen Pfade | Eng und auf den geänderten Bereich fokussiert | Breit und tief, das gesamte Produkt |
| Zeitpunkt | Bei jedem neuen Build und Deployment | Nach einem Bugfix oder einer kleinen Änderung | Vor Releases und nach größeren Änderungen |
| Typische Dauer | Minuten | Minuten bis eine Stunde | Stunden, manuell manchmal Tage |
| Geskriptet? | Ja, eine feste und stabile Suite | Oft ungeskriptet oder ad hoc | Ja, eine große gepflegte Suite |
| Meist automatisiert? | Fast immer | Manchmal | Überwiegend, mit einigen manuellen Prüfungen |
| Ergebnis bei Fehlschlag | Build abgelehnt, keine weiteren Tests | Fix geht zurück an den Entwickler | Release blockiert, bis die Fehler behoben sind |
Eine einfache Eselsbrücke: Smoke fragt „Läuft es?“, Sanity fragt „Ergibt das, was wir gerade geändert haben, Sinn?“ und Regression fragt „Funktioniert alles, was vorher funktioniert hat, noch?“ Einen umfassenderen Überblick über Testarten und wie QA-Teams sie kombinieren, gibt unser Leitfaden zur Qualitätssicherung in der Softwareentwicklung.
Wie funktioniert Smoke Testing in einer CI/CD-Pipeline?
In einer CI/CD-Pipeline läuft die Smoke-Suite automatisch direkt nach den Build- und Unit-Test-Stufen und erneut direkt nach jedem Deployment. Schlägt sie fehl, stoppt die Pipeline und der Build wird nicht weitergereicht. So wird Smoke Testing von einer manuellen Gewohnheit zu einem verbindlichen Quality Gate.
Ein typischer Ablauf sieht so aus: Build, Unit Tests, Deployment in eine Testumgebung, Smoke Tests, danach die längeren Funktions- und Regressionssuiten, dann das Deployment in die Produktion und schließlich ein Post-Deployment-Smoke-Test gegen die Produktion. Die beiden Smoke-Stufen fangen unterschiedliche Probleme ab. Der Smoke vor dem Release erkennt fehlerhaften Code, der Smoke nach dem Deployment erkennt fehlerhafte Konfiguration, Secrets, Migrationen und Infrastruktur.
Hier ein vereinfachter GitHub-Actions-Job, der eine Playwright-Smoke-Suite gegen eine frisch bereitgestellte Staging-Umgebung ausführt und die Pipeline scheitern lässt, sobald ein Smoke Test fehlschlägt:
smoke-test:
needs: deploy-staging
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- run: npm ci
- run: npx playwright install --with-deps chromium
- name: Run smoke suite against staging
run: npx playwright test --grep @smoke
env:
BASE_URL: https://staging.example.com
Zwei Details sorgen dafür, dass das in der Praxis funktioniert. Das Tag @smoke erlaubt es dem Team, Smoke Tests im Haupttestprojekt zu belassen und trotzdem nur die markierte Teilmenge auszuführen, und das Limit timeout-minutes verhindert, dass eine hängende Umgebung die Pipeline eine Stunde lang blockiert. Dasselbe Prinzip gilt für GitLab CI, Jenkins, Azure DevOps oder jeden anderen Runner. Zum vollständigen Pipeline-Design lesen Sie unseren Leitfaden zu CI/CD in der Softwareentwicklung.
Wie lange sollte eine Smoke-Test-Suite dauern?
Eine Smoke-Test-Suite sollte in der Regel in weniger als 5 bis 10 Minuten durchlaufen, viele Teams streben unter 5 Minuten an. Dauert sie länger, liefert sie kein schnelles Feedback mehr, und Entwickler beginnen, sie zu ignorieren oder zu umgehen. Wächst eine Suite über dieses Limit hinaus, verschieben Sie die langsameren oder weniger kritischen Prüfungen in die Regressionssuite, statt ein langsameres Gate hinzunehmen.
Smoke-Testing-Tools im Jahr 2026
Die meisten Teams bauen Smoke Tests mit denselben Automatisierungstools, die sie bereits für Funktionstests nutzen, und markieren dann eine kleine Teilmenge als Smoke-Suite. Welches Tool passt, hängt davon ab, was Sie testen: eine Browser-Oberfläche, eine Mobile App oder eine API.
| Ebene | Gängige Tools | Typische Smoke-Checks |
|---|---|---|
| Web-UI | Playwright, Cypress, Selenium WebDriver | Seitenaufruf, Login, zentraler Nutzerablauf |
| Mobile | Appium, Espresso (Android), XCUITest (iOS), Maestro | Installation, Start ohne Absturz, Anmeldung, Daten auf dem Startbildschirm |
| API | Postman mit Newman, REST Assured, pytest mit requests, k6 | Health-Endpoint, Auth-Token, je ein Lese- und ein Schreibaufruf |
| Test-Runner | JUnit, TestNG, pytest, Jest, Vitest | Gruppieren und Taggen der Smoke-Teilmenge |
| CI/CD | GitHub Actions, GitLab CI, Jenkins, Azure DevOps | Ausführen der Suite als Gate nach Build und Deployment |
| Produktionsprüfungen | Synthetisches Monitoring in Ihrer Observability-Plattform | Geplante Smoke-artige Prüfungen der kritischen Live-Pfade |
Die Wahl des Tools ist weniger wichtig als Disziplin. Eine Playwright-Suite mit zehn Tests, die bei jedem Merge läuft, ist mehr wert als ein ausgefeiltes Framework, das niemand pflegt.
Vorteile und Grenzen von Smoke Testing
Der größte Vorteil von Smoke Testing ist, dass es Build-brechende Fehler innerhalb von Minuten und zu sehr geringen Kosten aufdeckt. Die größte Grenze: Über die Qualität von allem außerhalb der kritischen Pfade sagt es fast nichts aus. Ein bestandener Smoke Test bedeutet „lohnt sich zu testen“, nicht „bereit für das Release“.
| Vorteile | Grenzen |
|---|---|
| Findet kritische Fehler innerhalb von Minuten nach einem Build | Bewusst oberflächlich, übersieht die meisten funktionalen Fehler |
| Spart QA-Zeit durch Ablehnung nicht testbarer Builds | Kann falsche Sicherheit erzeugen, wenn er als Release-Prüfung behandelt wird |
| Leicht zu automatisieren und bei jeder Änderung auszuführen | Braucht Wartung, wenn sich kritische Abläufe ändern |
| Fängt Umgebungs- und Konfigurationsfehler nach dem Deployment ab | Flaky Tests untergraben schnell das Vertrauen in das Gate |
| Liefert ein einfaches, gemeinsames Go- oder No-Go-Signal | Wird langsam, wenn Teams ständig nicht kritische Prüfungen hinzufügen |
Best Practices für Smoke Testing
Die besten Smoke-Suiten sind kurz, stabil, automatisiert und strikt auf kritische Pfade beschränkt. Die meisten Probleme beim Smoke Testing entstehen durch Suiten, die zu groß oder zu flaky geworden sind, um ihnen zu vertrauen. Diese sieben Praktiken halten eine Suite nützlich:
- Halten Sie sie klein. Beginnen Sie mit 5 bis 15 Prüfungen und fügen Sie nur dann eine neue hinzu, wenn ihr Fehlschlag weitere Tests sinnlos machen würde.
- Legen Sie ein Zeitbudget fest. Vereinbaren Sie eine maximale Laufzeit, etwa 5 Minuten, und behandeln Sie jede Überschreitung als Fehler.
- Machen Sie jeden Test unabhängig. Jede Prüfung sollte ihre eigenen Daten anlegen oder zurücksetzen und in beliebiger Reihenfolge laufen können.
- Beheben oder entfernen Sie flaky Tests sofort. Ein Gate, das zufällig fehlschlägt, bringt Menschen bei, es neu zu starten und zu ignorieren.
- Führen Sie sie in einer produktionsnahen Umgebung aus. Gleiche Art der Konfiguration, gleiche Integrationen im Sandbox-Modus, realistische Daten.
- Smoke-testen Sie die Produktion nach jedem Release. Nutzen Sie schreibgeschützte oder dedizierte Testkonten, damit Live-Prüfungen nie echte Kundendaten berühren.
- Überprüfen Sie die Suite jedes Quartal. Entfernen Sie Prüfungen für eingestellte Funktionen und ergänzen Sie Prüfungen für neue kritische Abläufe.
Kennzahlen für Ihre Smoke-Suite
Verfolgen Sie einige einfache Zahlen, um zu wissen, ob die Smoke-Suite ihre Aufgabe erfüllt: die Smoke-Erfolgsquote auf dem Hauptzweig, die mediane Laufzeit der Suite, die Quote flaky Fehlschläge (Fehlschläge, die beim erneuten Lauf bestehen) und die Zahl der Fehler, die erst in späteren Stufen gefunden wurden, obwohl ein Smoke Test sie hätte erkennen müssen. Diese Werte ergänzen auf natürliche Weise Delivery-Kennzahlen wie die Change Failure Rate, die unser Leitfaden zu KPIs in der Softwareentwicklung erklärt.
Häufige Fehler beim Smoke Testing
Der häufigste Fehler beim Smoke Testing ist, die Suite zu einer Mini-Regressionssuite anwachsen zu lassen, die zu lange dauert und zu oft fehlschlägt. Weitere typische Probleme sind leicht zu erkennen, wenn man sie kennt:
- Randfälle in der Smoke-Suite testen statt der kritischen Happy Paths.
- Smoke nur vor Releases ausführen statt bei jedem Build, was das Feedback um Tage verzögert.
- Den Post-Deployment-Smoke auslassen, sodass Konfigurationsfehler zuerst die Nutzer erreichen.
- Testdaten zwischen Tests teilen, was zufällige Fehlschläge verursacht, wenn Tests parallel laufen.
- Manuelles Übersteuern erlauben, wenn ein Smoke „nur dieses eine Mal“ fehlschlägt, was das Gate wirkungslos macht.
Wenn Ihre Releases trotz Smoke-Suite immer noch am ersten Tag brechen, kann eine unabhängige QA-Bewertung prüfen, welche kritischen Pfade tatsächlich abgedeckt sind, Flaky-Quoten und Laufzeiten messen und das Gate so neu aufbauen, dass das Team ihm wieder vertraut.
Häufig gestellte Fragen
Was ist Smoke Testing in der Softwareentwicklung?
Smoke Testing in der Softwareentwicklung ist eine schnelle Reihe von Prüfungen, die bei jedem neuen Build laufen und bestätigen, dass die kritischsten Funktionen arbeiten, etwa der Start, die Anmeldung und der Abschluss der Kerntransaktion. Es entscheidet, ob der Build stabil genug für tiefergehende Tests ist. Ein fehlgeschlagener Smoke Test führt zur sofortigen Ablehnung des Builds, sodass Tester keine Zeit mit grundlegend defekter Software verschwenden.
Was ist ein Smoke Test in der Softwareentwicklung, mit Beispiel?
Ein Smoke Test ist eine kurze automatisierte oder manuelle Prüfung der kritischen Pfade eines Builds. Bei einem Onlineshop könnte ein Smoke Test bestätigen, dass die Startseite lädt, sich ein Testnutzer anmelden kann, ein Produkt in den Warenkorb gelegt werden kann und eine Sandbox-Zahlung mit einer Bestellnummer abgeschlossen wird. Schlägt eine dieser Prüfungen fehl, geht der Build zurück an die Entwickler, bevor andere Tests beginnen.
Was ist der Unterschied zwischen Smoke Testing und Sanity Testing?
Smoke Testing ist eine breite, flache Prüfung, ob ein kompletter neuer Build stabil genug zum Testen ist. Sanity Testing ist eine enge Prüfung, ob ein bestimmter Bugfix oder eine kleine Änderung wie beabsichtigt funktioniert. Smoke Testing läuft bei jedem Build und ist fast immer automatisiert, während Sanity Testing nach gezielten Änderungen läuft und oft von Hand erfolgt. Manche Glossare, darunter das ISTQB-Glossar, behandeln beide Begriffe als Synonyme.
Ist Smoke Testing dasselbe wie ein Regressionstest?
Nein. Smoke Testing prüft in wenigen Minuten nur die kritischen Pfade eines neuen Builds, um zu entscheiden, ob er testbar ist. Ein Regressionstest führt eine deutlich größere Suite erneut aus, um zu bestätigen, dass bestehende Funktionen nach einer Änderung weiterhin arbeiten, und kann Stunden dauern. Smoke Testing läuft zuerst als Gate, Regressionstests laufen später, vor einem Release.
Wie viele Tests sollte eine Smoke-Test-Suite haben?
Die meisten Smoke-Suiten enthalten zwischen 5 und 30 Tests, und die richtige Zahl ist die kleinste Menge, die jeden kritischen Pfad des Produkts abdeckt. Eine nützliche Regel: Nehmen Sie eine Prüfung nur auf, wenn ihr Fehlschlag alle weiteren Tests sinnlos machen würde. Dauert die Suite länger als etwa 5 bis 10 Minuten, ist sie vermutlich zu groß geworden.
Lassen sich Smoke Tests automatisieren?
Ja, und bei jedem Produkt mit CI/CD-Pipeline sollten sie es sein. Automatisierte Smoke Tests laufen bei jedem Build und Deployment mit Tools wie Playwright, Cypress, Appium oder Postman mit Newman und blockieren die Pipeline, wenn eine kritische Prüfung fehlschlägt. Manuelle Smoke-Checklisten sind für frühe Prototypen und für visuelle Prüfungen, die sich schwer automatisieren lassen, weiterhin sinnvoll.
Wer ist für Smoke Testing verantwortlich?
QA- oder Testautomatisierungs-Engineers entwerfen und pflegen die Smoke-Suite in der Regel, DevOps-Engineers binden sie in die CI/CD-Pipeline ein, und Entwickler beheben jeden Build, der sie nicht besteht. In kleinen Teams ohne eigene Tester übernehmen die Entwickler den gesamten Prozess. Wer auch immer zuständig ist: Eine Person sollte klar dafür verantwortlich sein, die Suite schnell und zuverlässig zu halten.
Quellen
- ISTQB, Glossary of Terms used in Software Testing, Einträge „smoke test“ und „build verification test“ (v4.2, 2023)
- Steve McConnell, Daily Build and Smoke Test, IEEE Software, Bd. 13, Nr. 4, Juli 1996, S. 143–144
- NIST, Planning Report 02-3: The Economic Impacts of Inadequate Infrastructure for Software Testing (2002)
- Playwright-Dokumentation, Test annotations and tags