SkillForge | ATLAS

Testing und Verifizierung

17 min read

Testing und Verifizierung

In dieser Lerneinheit tauchst du in die verschiedenen Teststufen der Softwareentwicklung ein und lernst die Unterschiede zwischen Unit-, Integrations- und Systemtests kennen. Du verstehst, wann welche Testmethode sinnvoll einzusetzen ist und wie die verschiedenen Teststufen aufeinander aufbauen. Diese Kenntnisse wendest du direkt in der Praxis an, um die Qualität deiner Software systematisch und effizient zu sichern.

Einführung

Die neue App ist fertig entwickelt, alle Features funktionieren. Du klickst auf “Deploy” und schickst sie live. Zwei Stunden später: Der Kundensupport bricht zusammen unter Beschwerden. Ein Button funktioniert nicht. Ein Formular speichert keine Daten. Die App stürzt ab, wenn jemand einen Umlaut eingibt.

Ohne Tests: Code stürzt ab - Mit Tests: Sicherheitsnetz fängt Fehler
Ohne Tests vs. Mit Tests: Das Sicherheitsnetz aus Teststufen — Bildrechte: Ausbildung-in-der-IT.de (KI-unterstützt)

Wie hätte man das verhindern können?

Die Antwort liegt in einem systematischen Testprozess. Software-Testing ist keine lästige Pflicht am Ende der Entwicklung, sondern ein integraler Bestandteil jeder professionellen Softwareentwicklung. Es gibt verschiedene Teststufen, Testverfahren und Automatisierungsmöglichkeiten, die zusammen ein Sicherheitsnetz bilden.

In dieser Lerneinheit erfährst du, wie Teststufen aufeinander aufbauen, welche Testverfahren es gibt und wie moderne Testautomatisierung und CI/CD-Pipelines Qualität messbar machen.

Lernziele

Nach dieser Lerneinheit kannst du:

  • Die vier Teststufen (Unit, Integration, System, Acceptance) unterscheiden und ihre Ziele erklären
  • Testverfahren wie Black-Box, White-Box und Gray-Box beschreiben und situationsgerecht einsetzen
  • Grundlagen der Testautomatisierung und des Testmanagements anwenden
  • Kontinuierliche Integration (CI) und Continuous Testing (CT) in der Praxis einordnen

Überleitung

Um Softwarefehler systematisch zu finden, bevor sie Nutzer erreichen, gibt es verschiedene Teststufen. Jede Stufe hat einen anderen Fokus und findet unterschiedliche Arten von Fehlern.

Beginnen wir mit der grundlegenden Frage: Was genau bedeutet Software-Testing und warum ist es so wichtig?

Was ist Software-Testing?

Software-Testing ist der systematische Prozess, Software auf Fehler zu prüfen und sicherzustellen, dass sie die definierten Anforderungen erfüllt. Dabei werden verschiedene Eingaben und Szenarien durchgespielt, um das tatsächliche Verhalten mit dem erwarteten Verhalten zu vergleichen.

Warum ist Testing wichtig?

  • Frühe Fehlererkennung: Je früher ein Fehler gefunden wird, desto günstiger ist seine Behebung
  • Qualitätssicherung: Tests belegen, dass die Software die Anforderungen erfüllt
  • Vertrauensbildung: Stakeholder und Nutzer vertrauen getesteter Software mehr
  • Dokumentation: Testfälle dokumentieren das erwartete Verhalten

Die Teststufen im Überblick

Software-Testing folgt einer Stufenlogik: Von kleinen Einheiten bis zur vollständigen Anwendung werden verschiedene Aspekte getestet. Jede Stufe baut auf der vorherigen auf.

Denke an eine Pyramide: Unten viele schnelle Unit-Tests, oben wenige aufwändige Systemtests.

Die vier klassischen Teststufen sind:

  1. Unit Testing - Einzelne Funktionen oder Methoden
  2. Integration Testing - Zusammenspiel mehrerer Module
  3. System Testing - Die gesamte Anwendung
  4. Acceptance Testing - Abnahme durch Nutzer oder Kunden

Unit Testing

Beim Unit Testing liegt der Fokus auf der kleinsten testbaren Einheit des Codes: einzelne Funktionen oder Methoden. Ziel ist es, sicherzustellen, dass jede Einheit isoliert korrekt arbeitet.

Typische Werkzeuge:

  • JUnit für Java-Anwendungen
  • NUnit für .NET
  • PyTest für Python

Vorteile von Unit Tests:

  • Schnelle Ausführung (Millisekunden)
  • Frühe Fehlererkennung direkt beim Entwickeln
  • Vereinfachung der Fehlerbehebung durch Isolation
  • Verbesserung des Code-Designs (Test-Driven Development)

Integration Testing: Grundlagen

Integration Testing prüft das Zusammenspiel mehrerer Module. Selbst wenn jedes Modul für sich korrekt funktioniert, können Probleme entstehen, wenn sie miteinander kommunizieren.

Typische Fehler, die Integration Tests finden:

  • Inkompatible Datenformate zwischen Modulen
  • Falsche API-Aufrufe oder Parameter
  • Timing-Probleme bei asynchroner Kommunikation
  • Fehlende oder falsche Fehlerbehandlung an Schnittstellen

Typische Werkzeuge:

  • Postman für API-Tests
  • Selenium für UI-Integrationstests

Integration Testing: Ansätze

Es gibt verschiedene Strategien, Module schrittweise zu integrieren:

Big Bang Integration: Alle Module werden erst fertiggestellt und dann auf einmal integriert.

  • Vorteil: Schnell, wenn alle Module fertig sind
  • Nachteil: Fehlersuche schwierig, da alle Fehler gleichzeitig auftreten

Top-Down Integration: Test beginnt mit höheren Modulen. Für niedrigere Module werden Stubs (Dummy-Module) verwendet.

  • Vorteil: Frühe Tests möglich, kritische Module zuerst
  • Nachteil: Stubs müssen erstellt werden

Bottom-Up Integration: Test beginnt mit niedrigeren Modulen. Für höhere Module werden Drivers verwendet.

  • Vorteil: Keine Stubs nötig für niedrige Module
  • Nachteil: Drivers erforderlich, UI-Tests später

Sandwich/Hybrid: Kombination aus Top-Down und Bottom-Up.

  • Vorteil: Parallel arbeiten, schnellere Integration
  • Nachteil: Komplex, mehr Aufwand

System Testing

Beim System Testing wird die komplette Anwendung in einer produktionsähnlichen Umgebung getestet. Im Fokus steht die Überprüfung der gesamten Funktionalität sowie nicht-funktionaler Anforderungen.

Was wird beim System Testing geprüft?

  • Funktionalität: Erfüllt die Software alle spezifizierten Anforderungen?
  • Usability: Ist die Anwendung benutzerfreundlich?
  • Performance: Wie verhält sich die Software unter Last?
  • Sicherheit: Sind Daten und Zugriffe geschützt?

Vorgehen: Verwendung realistischer Szenarien und Daten, um das Verhalten unter Produktionsbedingungen zu simulieren. System Tests sind aufwändiger als Unit- oder Integration Tests, finden aber Fehler, die erst im Zusammenspiel aller Komponenten auftreten.

Acceptance Testing

Acceptance Testing dient der finalen Überprüfung durch den Kunden oder Nutzer. Die zentrale Frage: Erfüllt die Software die Geschäftsbedürfnisse und ist sie zur Auslieferung bereit?

Typen von Acceptance Tests:

  • Alpha-Testing: Wird beim Entwickler durch interne Tester durchgeführt
  • Beta-Testing: Echte Endnutzer testen in ihrer eigenen Umgebung
  • User Acceptance Testing (UAT): Formale Abnahme durch Stakeholder

Beteiligte: Endnutzer, Stakeholder, Produkt-Manager

Ergebnis: Go/No-Go-Entscheidung für die Freigabe der Software. Ein erfolgreiches Acceptance Testing bestätigt, dass die Software nicht nur technisch funktioniert, sondern auch den Geschäftsanforderungen entspricht.

Übersicht: Teststufen

Die folgende Tabelle fasst die vier Teststufen zusammen:

TeststufeFokusTypische WerkzeugeWer testet?
Unit TestingEinzelne Funktionen/MethodenJUnit, NUnit, PyTestEntwickler
Integration TestingZusammenspiel von ModulenPostman, SeleniumEntwickler, QA
System TestingGesamte AnwendungSelenium, LoadRunnerQA-Team
Acceptance TestingGeschäftsanforderungenManuelle Tests, CucumberNutzer, Stakeholder

Jede Stufe baut auf der vorherigen auf: Erst wenn Unit Tests bestehen, macht Integration Testing Sinn. Erst wenn das System als Ganzes funktioniert, kann die Abnahme erfolgen.

Black-Box-Testing

Beim Black-Box-Testing wird die Software aus der externen Perspektive getestet, ohne Kenntnisse über die interne Implementierung. Der Tester verhält sich wie ein Endnutzer und prüft nur Eingaben und Ausgaben.

Vorteile:

  • Keine Notwendigkeit, den Code zu verstehen
  • Simuliert die echte Nutzererfahrung
  • Identifiziert Inkonsistenzen zwischen Verhalten und Spezifikation

Nachteile:

  • Kann interne Fehler übersehen
  • Begrenzte Abdeckung, wenn nicht alle Funktionalitäten getestet werden

Anwendungsbeispiele:

  • Formularüberprüfung: Eingabe ungültiger Daten und Prüfung der Fehlermeldungen
  • Navigationsfluss testen: Führen alle Buttons zur richtigen Seite?

White-Box-Testing

White-Box-Testing (auch “Glass-Box-Testing”) erfordert genaue Kenntnisse über den internen Aufbau der Anwendung: Code, Architektur und Programmlogik. Der Fokus liegt auf dem Testen interner Pfade und Zustände.

Vorteile:

  • Ermöglicht gründliche Prüfung des Codes und der Strukturen
  • Kann komplexe Szenarien und Zustände testen, die von außen nicht sichtbar sind

Nachteile:

  • Zeitintensiv und erfordert tiefgreifende Kenntnisse
  • Kann sich zu sehr auf technische Aspekte konzentrieren und die Nutzerperspektive vernachlässigen

Anwendungsbeispiele:

  • Testen von Schleifen und bedingten Anweisungen auf korrektes Verhalten
  • Überprüfung der Kommunikation zwischen Komponenten oder Diensten

Gray-Box-Testing

Gray-Box-Testing kombiniert Aspekte des Black-Box- und White-Box-Testings. Tester haben partiellen Zugriff oder Verständnis der internen Strukturen, konzentrieren sich aber hauptsächlich auf die externe Funktionalität.

Vorteile:

  • Ausgewogener Ansatz durch Berücksichtigung beider Perspektiven
  • Effektiveres und effizienteres Finden bestimmter Fehlerarten

Nachteile:

  • Erfordert sowohl Verständnis der internen Strukturen als auch der Nutzererfahrung
  • Kann schwierig sein ohne vollständige interne Dokumentation

Anwendungsbeispiele:

  • Sicherheitstests durch Untersuchung der Datenverarbeitungslogik und Eingabevalidierung
  • Leistungsüberprüfung unter Berücksichtigung interner Prozessabläufe

Übersicht: Testverfahren

Die folgende Tabelle vergleicht die drei Testverfahren:

VerfahrenCode-KenntnisFokusTypische Anwendung
Black-BoxKeineEingabe/AusgabeFunktionale Tests, UAT
White-BoxVollständigInterne LogikUnit Tests, Code Coverage
Gray-BoxTeilweiseBeidesAPI-Tests, Sicherheitstests

Jedes Verfahren hat seine Stärken und Einsatzgebiete. In der Praxis werden sie oft kombiniert, um eine umfassende Qualitätssicherung zu erreichen. Die Wahl des Verfahrens hängt vom Testziel, der verfügbaren Dokumentation und dem Know-how des Testers ab.

⏳ Lädt Dataview-Inhalt...

Testautomatisierung: Grundlagen

Testautomatisierung bezeichnet den Einsatz von Software-Werkzeugen, die automatisch Tests ausführen, Ergebnisse mit erwarteten Ausgaben vergleichen und detaillierte Berichte generieren.

Populäre Werkzeuge:

  • Selenium für Webanwendungen (Browser-Automatisierung)
  • JUnit für Java-Anwendungen (Unit Tests)
  • PyTest für Python (Unit und Integration Tests)
  • Postman für API-Tests

Vorteile der Automatisierung:

  • Schnellere Testausführung und häufigere Testläufe
  • Konsistente Ergebnisse ohne menschliche Fehler
  • Ermöglicht Regressionstests bei jeder Code-Änderung
  • Spart langfristig Zeit und Kosten

Testautomatisierung: Skripterstellung und Wartung

Automatisierte Testskripte werden oft mit Skriptsprachen wie Python oder JavaScript erstellt. Dabei gibt es wichtige Aspekte zu beachten:

Skripterstellung:

  • Testskripte sollten modular und wiederverwendbar sein
  • Klare Benennung und Dokumentation erleichtern die Wartung
  • Page-Object-Pattern bei UI-Tests reduziert Duplikation

Wartung:

  • Testskripte müssen regelmäßig aktualisiert werden, wenn sich die Anwendung ändert
  • Je modularer die Tests, desto geringer der Wartungsaufwand
  • Flaky Tests (instabile Tests) sollten identifiziert und behoben werden

Ein gut strukturiertes Test-Framework spart langfristig mehr Zeit als es initial kostet.

Moderne Test-Frameworks

Neben den etablierten Werkzeugen gibt es modernere Alternativen, die in vielen Projekten an Bedeutung gewinnen:

  • Playwright: Von Microsoft entwickelt. Unterstützt mehrere Browser (Chrome, Firefox, Safari) mit einer einzigen API. Bietet bessere Performance und stabilere Tests als Selenium.

  • Cypress: Speziell für moderne Webanwendungen entwickelt. Läuft direkt im Browser, was schnellere Ausführung und besseres Debugging ermöglicht. Besonders beliebt bei Frontend-Entwicklern.

  • TestCafe: Keine WebDriver-Abhängigkeit nötig. Einfache Einrichtung und gute Unterstützung für moderne JavaScript-Frameworks.

Die Wahl des Frameworks hängt vom Projekt, dem Tech-Stack und den Teamkenntnissen ab. Selenium bleibt weit verbreitet, aber die neueren Alternativen bieten oft eine bessere Developer Experience.

AI-gestütztes Testing

Künstliche Intelligenz verändert zunehmend die Art, wie Software getestet wird:

  • Predictive Analytics: KI kann vorhersagen, welche Code-Bereiche fehleranfällig sind und priorisiert Tests entsprechend. Das spart Zeit und findet kritische Bugs schneller.

  • Automatische Fehlerdiagnose: ML-Modelle analysieren Fehlermeldungen und Logs, um die wahrscheinliche Ursache eines Problems zu identifizieren.

  • Self-Healing Tests: Wenn sich UI-Elemente ändern (z.B. ein Button bekommt eine neue ID), passt die KI die Test-Selektoren automatisch an, statt dass der Test fehlschlägt.

  • Generative AI: Große Sprachmodelle können Testfälle aus Anforderungen oder User Stories generieren und so den manuellen Aufwand reduzieren.

AI-Testing ersetzt nicht die menschliche Expertise, sondern ergänzt sie, indem Routineaufgaben automatisiert und intelligente Entscheidungen unterstützt werden.

Testmanagement: Planung und Organisation

Testmanagement umfasst die Planung, Steuerung und Dokumentation aller Testaktivitäten. Es ist entscheidend für die Koordination der Tests und die Sicherstellung der Anforderungsabdeckung.

Testplanung:

  • Definition der Teststrategie und Testziele
  • Festlegung des Testumfangs und der Testumgebungen
  • Priorisierung der Testfälle nach Risiko

Testorganisation:

  • Definition von Rollen und Verantwortlichkeiten
  • Festlegung der Kommunikationswege im Team
  • Koordination zwischen Entwicklern und QA-Team

Werkzeuge:

  • Jira für Aufgabenverwaltung und Bug-Tracking
  • TestRail für Testfallmanagement und Reporting

Testmanagement: Durchführung und Dokumentation

Testdurchführung:

  • Ausführung der geplanten Tests nach definiertem Zeitplan
  • Überwachung des Fortschritts und Anpassung bei Bedarf
  • Eskalation bei kritischen Fehlern

Testdokumentation:

  • Dokumentation aller Testfälle mit erwarteten Ergebnissen
  • Protokollierung der Testergebnisse (Pass/Fail)
  • Erstellung von Testberichten mit wichtigen Metriken

Wichtige Metriken:

MetrikBeschreibung
TestabdeckungWie viel Code wird durch Tests geprüft?
FehlerdichteAnzahl Fehler pro Codezeile/Modul
Defect Escape RateFehler, die erst nach Release gefunden wurden
Test Pass RateAnteil bestandener Tests

Diese Metriken helfen, den Testfortschritt zu bewerten und Verbesserungspotenzial zu identifizieren.

Kontinuierliche Integration (CI)

Continuous Integration (CI) ist eine Entwicklungspraxis, bei der Entwickler ihre Änderungen regelmäßig (oft mehrmals täglich) in ein zentrales Repository integrieren. Nach jedem Upload werden automatisch Builds und Tests durchgeführt.

Vorteile von CI:

  • Früherkennung von Fehlern: Durch automatische Tests nach jedem Commit werden Fehler schnell identifiziert
  • Verbesserung der Softwarequalität: Kontinuierliches Feedback ermöglicht iterative Verbesserung
  • Effiziente Zusammenarbeit: Kleinere, häufige Änderungen erleichtern die Teamarbeit
  • Reduzierte Integrationsrisiken: Probleme werden früh erkannt, nicht erst am Ende

Populäre CI-Tools:

  • Jenkins (Open Source, sehr flexibel)
  • GitHub Actions (integriert in GitHub)
  • GitLab CI/CD (integriert in GitLab)
  • CircleCI (Cloud-basiert, einfache Einrichtung)

Continuous Testing (CT)

Continuous Testing (CT) ist eine Erweiterung von CI. Tests werden automatisch und in einer kontinuierlichen Feedback-Schleife durchgeführt, unabhängig davon, in welcher Phase des Entwicklungsprozesses sich das Projekt befindet.

Vorteile von CT:

  • Schnelle Fehlerbehebung: Fehler werden sofort erkannt und können behoben werden, bevor sie größere Probleme verursachen
  • Höhere Testabdeckung: Automatisierte Tests können häufiger und umfassender durchgeführt werden
  • Schnellere Markteinführung: Die kontinuierliche Bewertung der Qualität beschleunigt den Release-Prozess

Shift-Left Testing: Ein wichtiges Prinzip von CT. Tests werden so früh wie möglich im Entwicklungszyklus durchgeführt, nicht erst am Ende. Das bedeutet: Sicherheits- und Performance-Tests bereits während der Entwicklung, nicht erst vor dem Release.

CI/CD-Pipeline

Eine CI/CD-Pipeline automatisiert den Prozess von der Code-Änderung bis zum Deployment. Das folgende Diagramm zeigt den grundlegenden Ablauf:

graph LR;
    A(Code Commit) --> B(CI Server);
    B --> C{Automatisierte Tests};
    C -->|Bestanden| D(Deployment);
    C -->|Fehlgeschlagen| E(Fehlerbehebung);

Ablauf:

  1. Code Commit: Entwickler pusht Änderungen ins Repository
  2. CI Server: Erkennt die Änderung und startet den Build
  3. Automatisierte Tests: Unit-, Integration- und weitere Tests werden ausgeführt
  4. Ergebnis: Bei Erfolg wird deployed, bei Fehlschlag wird der Entwickler benachrichtigt

Das “Fail Fast”-Prinzip sorgt dafür, dass fehlerhafte Änderungen nicht in Produktion gelangen.

Best Practices für CI/CT

Für erfolgreiche CI/CT-Implementierung:

  • Build-Prozess kurz halten: Der Build sollte nicht länger als 10 Minuten dauern. Schnelles Feedback ermöglicht schnelle Korrekturen.

  • Testumgebungen spiegeln Produktion: Je ähnlicher Test- und Produktionsumgebung, desto aussagekräftiger die Tests.

  • Feature-Toggles nutzen: Unvollständige Features können gemerged werden, ohne die Funktionalität zu beeinträchtigen. Das Feature wird erst aktiviert, wenn es fertig ist.

  • Alles automatisieren: Nicht nur Tests, sondern auch Deployment, Monitoring und Rollback-Mechanismen.

  • Shift-Left Testing: Sicherheits- und Performance-Tests früh integrieren, nicht erst am Ende.

  • Regelmäßige Commits: Kleine, häufige Commits sind besser als große, seltene. Sie reduzieren Merge-Konflikte und erleichtern die Fehlersuche.

⏳ Lädt Dataview-Inhalt...

Zusammenfassung und Ausblick

Zusammenfassung

Software-Testing ist ein systematischer Prozess zur Qualitätssicherung, der verschiedene Ebenen und Methoden umfasst. Die vier Teststufen bauen aufeinander auf:

Unit Testing prüft einzelne Funktionen und Methoden isoliert. Werkzeuge wie JUnit, NUnit oder PyTest ermöglichen schnelle, automatisierte Tests auf Code-Ebene. Integration Testing testet das Zusammenspiel mehrerer Module und nutzt dabei verschiedene Ansätze: Big Bang integriert alle Module gleichzeitig, Top-Down beginnt mit höheren Modulen (Stubs für niedrigere), Bottom-Up startet mit niedrigeren Modulen (Drivers für höhere), und Sandwich kombiniert beide Ansätze.

System Testing prüft die gesamte Anwendung in produktionsähnlicher Umgebung auf Funktionalität, Usability, Performance und Sicherheit. Acceptance Testing schließlich bestätigt durch Alpha-, Beta-Tests oder UAT, dass die Software die Geschäftsanforderungen erfüllt.

Die drei Testverfahren unterscheiden sich nach Code-Kenntnis: Black-Box testet ohne Implementierungswissen, White-Box mit vollständigem Code-Zugriff, und Gray-Box kombiniert beide Perspektiven. In der Praxis werden sie oft zusammen eingesetzt.

Testautomatisierung mit Werkzeugen wie Selenium, Playwright oder Cypress erhöht Effizienz und Konsistenz. Moderne Ansätze wie AI-gestütztes Testing nutzen Predictive Analytics, Self-Healing Tests und automatische Testfallgenerierung.

Continuous Integration (CI) und Continuous Testing (CT) bilden das Rückgrat moderner Entwicklung. CI integriert Code regelmäßig mit automatischen Builds und Tests, CT erweitert dies durch kontinuierliches Feedback in allen Entwicklungsphasen. Das Shift-Left-Prinzip verlagert Tests früh in den Entwicklungszyklus.

Ausblick

In der nächsten Lerneinheit Betrieb und Wartung lernst du, wie du Software nach dem Deployment überwachst und wartest. Du erfährst, welche KPIs im Betrieb wichtig sind, wie Monitoring funktioniert und wie Incident Management die Softwarequalität langfristig sichert.

Graphansicht

Backlinks