Testen

Systemtest und Abnahmetest: Die ganze Anwendung über HTTP prüfen mit RestTestClient

Bisher hat jeder Test nur einen Ausschnitt der Anwendung gestartet. Jetzt läuft das Mitfahr-Backend vollständig mit Tomcat und Datenbank, und RestTestClient schickt echte HTTP-Anfragen. Ein Systemtest prüft jede Antwort gegen den API-Vertrag openapi.yaml, ein Abnahmetest jedes Abnahmekriterium der User Stories aus Artikel 01. Beide finden je eine echte Lücke. Dazu kommen ein Abnahmeprotokoll, CORS für Browser-Frontends und eine eigene Stufe in der Pipeline.

Übungsaufgaben zum Controller-Integrationstest: Die Gesuch-Endpunkte absichern

Übungen zum Integrationstest der Web-Schicht im Mitfahr-Backend: Du ordnest zu, was @WebMvcTest startet, liest einen Controller-Test, schreibst Tests für das Einstellen von Mitfahrgesuchen und ihre Fehlerfälle, findest heraus, warum ein Test ohne @WebMvcTest mit „Request failed unexpectedly“ scheitert, und bewertest, was ein Test mit Mocks wirklich beweist.

Die Web-Schicht im Test: Controller-Integrationstests mit @WebMvcTest und MockMvcTester

Bisher prüfen nur .http-Dateien von Hand, ob die Controller richtig antworten. Jetzt übernimmt das ein Integrationstest der Web-Schicht: @WebMvcTest startet nur den Web-Teil von Spring, @MockitoBean ersetzt den Service durch einen Mock, und MockMvcTester schickt Anfragen ohne echten Server. Damit lassen sich Statuscodes, Header, JSON und alle Fehlerfälle aus Artikel 09 mit Problem Details automatisch prüfen. Unterwegs zeigen zwei Stolpersteine, was ein Testausschnitt (Slice) weglässt.

Übungsaufgaben zu Repository-Integrationstests: passende Mitfahrgesuche finden

Übungen zu Abfragen und Integrationstests im Mitfahr-Backend: Du übersetzt Methodennamen in SQL, ordnest Aussagen zu @DataJpaTest ein, schreibst eine JPQL-Abfrage, die zu einer Abfahrtszeit die passenden Mitfahrgesuche findet, testest sie an den Grenzen des Zeitfensters und findest heraus, warum ein Test allein grün und in der Testsuite rot ist und warum ein anderer nur in der Pipeline mit MariaDB scheitert.

Abfragen schreiben und testen: Repository-Integrationstests mit @DataJpaTest

Die Repositories aus Artikel 06 können bisher nur, was sie von JpaRepository geerbt haben. Jetzt bekommen sie eigene Abfragen: aus dem Methodennamen abgeleitet oder mit @Query in JPQL geschrieben. Ob diese Abfragen das Richtige finden, prüfen Integrationstests mit @DataJpaTest gegen eine echte Datenbank: H2 beim täglichen Testlauf, MariaDB in der Pipeline. Nebenbei beantwortet GET /angebote endlich Suchanfragen.

Übungsaufgaben zu Service-Schicht und Dependency Injection: Mitfahrgesuche einstellen und zurückziehen

Übungen zur Service-Schicht im Mitfahr-Backend: Du erkennst die drei Arten der Dependency Injection, beurteilst Aussagen zu Mocks und Transaktionen, schreibst einen GesuchService mit Konstruktorinjektion und einer injizierten Uhr, testest ihn mit Mockito und findest heraus, warum ein zurückgezogenes Gesuch trotz grüner Tests offen bleibt und warum das Abdeckungs-Gate ein anderes Paket meldet als erwartet.

Fachlogik verdrahten: Service-Schicht, Dependency Injection und Tests mit Mockito

Bisher speichert der Controller Angebote direkt über die Repositories, und keine der Fachregeln aus Artikel 04 wird geprüft. Jetzt kommt eine Service-Schicht dazwischen: Spring setzt Controller, Services, Repositories und eine Uhr per Konstruktorinjektion zusammen, @Transactional macht aus jeder Buchungsänderung eine Transaktion, und Buchungen lassen sich endlich anfragen, bestätigen und stornieren. Getestet wird der Service mit Mockito ganz ohne Datenbank; ein Abdeckungs-Gate lässt den Build scheitern, wenn die Tests zu wenig prüfen.

Übungsaufgaben zur Fachlogik und zum Komponententest: Regeln für Mitfahrgesuche

Übungen zur Fachlogik im Mitfahr-Backend: Du bildest Äquivalenzklassen und Grenzwerte für einen Kostenbeitrag, ordnest JUnit-Zusicherungen zu, schreibst einen parametrisierten Test zur Einwilligung, setzt die Zeitfensterregel für Gesuche samt Tests um, testest die Statuswechsel eines Gesuchs vollständig und findest einen Rundungsfehler, den double verursacht.

Fachlogik in reinem Java: Komponententests für Kostenbeitrag, Einwilligung und Buchungsstatus

Die Regeln, die der API-Vertrag nicht ausdrücken kann, kommen ins Paket domain: der Kostenbeitrag je Kilometer, die Einwilligung bei Minderjährigen und die erlaubten Wechsel des Buchungsstatus. Sie entstehen in reinem Java ohne Spring, mit BigDecimal, LocalDate, einem switch-Ausdruck und eigenen Exceptions. Mit Äquivalenzklassen und Grenzwerten findest Du die Testfälle und prüfst sie mit parametrisierten JUnit-Tests: die erste Testebene des V-Modells, der Komponententest.

Übungsaufgaben zu Whitebox-Tests und Überdeckungsmaßen

Zwei Übungsaufgaben zu Whitebox-Tests: durchlaufene und fehlende Anweisungen bestimmen, Anweisungs-, Zweig- und Pfadüberdeckungsgrad berechnen, Testdaten ergänzen, die Zahl der Pfade berechnen, die Mindestzahl an Testfällen bestimmen, eine englische Projektrichtlinie anwenden, einen Unit-Test formulieren und die Wahl eines Überdeckungsmaßes begründen.

Übungsaufgaben zu Unit-Tests, Testfällen und Fehlersuche im Code

Drei umfangreiche Übungsaufgaben: Du bildest Äquivalenzklassen, schreibst parametrisierte Tests mit JUnit und pytest, wertest Testberichte und Fehlermeldungen aus, entscheidest, ob Code oder Test falsch ist, beurteilst Tests nach den F.I.R.S.T.-Regeln, verfolgst eine rekursive Methode, vergleichst zwei Umsetzungen anhand von Testfällen, hinterfragst die Aussagekraft der Anweisungsüberdeckung und suchst Fehler in kurzen Python-Skripten – auch mit Datenverlaufstabelle, Debugger und testgetriebener Entwicklung.

Unit-Tests, Testfälle und Fehlersuche im Code

Ein Unit-Test prüft automatisch, ob eine kleine Einheit des Programms – meist eine Methode – zu bestimmten Eingaben das erwartete Ergebnis liefert. Der Artikel zeigt, was gute Unit-Tests auszeichnet, wie Du mit JUnit Testfälle formulierst und auswertest, wie Du Testdaten über Äquivalenzklassen und Grenzwerte findest und wie Du mit Schreibtischtest, Datenverlaufstabelle und Debugger Laufzeit- und semantische Fehler im Code – auch in kurzen Skripten – aufspürst und korrigierst.

Übungsaufgaben zu Teststrategie und Qualitätssicherung

Drei Übungsaufgaben zu Maßnahmen der Qualitätssicherung, Reviews und statischer Codeanalyse, Blackbox- und Whitebox-Tests, Teststufen im V-Modell, Regressionstests, Testkonzept und Testdaten, User Acceptance Test sowie Syntax-, Semantik- und Laufzeitfehlern. Dazu bewertest Du Vorschläge aus dem Projektteam und machst Gegenvorschläge.

Teststrategie und Qualitätssicherung: Wie Software gut wird und gut bleibt

Gute Software entsteht nicht durch Zufall und auch nicht durch einen einzigen Test am Schluss. Dieser Artikel ordnet die Maßnahmen der Qualitätssicherung (konstruktiv, analytisch, statisch, dynamisch), erklärt Reviews und statische Codeanalyse, vergleicht Blackbox- und Whitebox-Tests, unterscheidet Syntax-, Semantik- und Laufzeitfehler, stellt die Teststufen im V-Modell und den User Acceptance Test vor, zeigt, wofür Regressionstests da sind, und beschreibt, was in ein Testkonzept gehört.

Programmentwürfe lesen, prüfen und korrigieren: Pseudocode, Struktogramm und PAP

Ob Pseudocode, Struktogramm oder Programmablaufplan – oft musst Du einen fremden Entwurf nicht neu schreiben, sondern lesen, testen und reparieren. Der Artikel zeigt die Bausteine der drei Darstellungsformen nebeneinander, erklärt den Schreibtischtest mit Trace-Tabelle und Testfalltabelle, stellt die typischen Fehlerarten mit Korrektur vor und zeigt, wie Du Lücken in Vorgaben ergänzt und einen PAP in ein Struktogramm überträgst.

Whitebox-Übungsaufgabe „Sortierung“: Kontrollflussgraph, McCabe-Zahl und Überdeckung

Zu einer gegebenen Funktion (ein Sortieralgorithmus) soll ein Kontrollflussgraph erstellt werden, die McCabe-Zahl berechnet werden (beides optional), die Überdeckungsmetriken für einen bestehenden Test berechnet werden, weitere Tests aus Whitebox-Sicht ergänzt werden und alles mit einem Code-Coverage-Tool implementiert werden.

Blackboxtest- und Algorithmus-Übungsaufgabe „Gesamtnote und Bestehensregeln“

Übungsaufgaben zur Erstellung von Testfällen nach Blackbox-Systematik für eine Funktion, die aus den Einzelergebnissen die Abschlussnote nach den Bestehensregeln der Ausbildungsverordnung berechnet. Du bestimmst systematisch Äquivalenzklassen und Grenzwerte und formulierst abschließend den Algorithmus in Pseudocode.

Versandkostenrechner-Übungsaufgabe zur Testfallerstellung nach Whitebox-Systematik

Zu einer gegebenen Java-Methode (Versandkostenrechner) erstellst Du einen Kontrollflussgraphen und berechnest die McCabe-Zahl (beides optional), bestimmst Anweisungs- und Zweigüberdeckung eines vorhandenen Tests, ergänzt weitere Testfälle nach Whitebox-Systematik, prüfst alles mit dem Code-Coverage-Werkzeug JaCoCo und suchst einen logischen Fehler, den die Whitebox-Sicht übersieht.

Tests gegen die Spezifikation erstellen: Blackbox-Testfälle

Die Spezifikation sagt uns vor der ersten Zeile Code eines neuen Programmblocks, wie dieser sich verhalten soll. Wir können im Vorhinein für mögliche Eingabewerte das Resultat unseres Codeblocks bestimmen. Die systematische Ermittlung und Dokumentation dieser Kombinationen aus Eingabewerten und Resultaten durch Äquivalenzklassenbildung und Grenzwertanalyse mündet in „Blackbox“-Testfällen.