Programmierung

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.

Fehler mit Format: restliche Endpunkte, Mapper und Problem Details nach RFC 9457

Seit Artikel 08 greifen die Fachregeln, aber jeder Verstoß endet als 500 Internal Server Error. Jetzt bekommt jede fachliche Ausnahme den Statuscode aus dem Vertrag: 404, 409 oder 422, beschrieben als Problem Details nach RFC 9457. Eine zentrale Klasse mit @RestControllerAdvice übernimmt das für alle Controller, auch für Vertragsverstöße (400). Dazu kommen die restlichen Endpunkte (Angebot ändern und absagen, Buchungen eines Angebots, Flurmonitor) und eigene Mapper-Klassen für die Umwandlung zwischen Entities und Vertragsmodellen.

Ü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 zur Persistenz mit JPA: Mitfahrgesuche in der Datenbank speichern

Übungen zur Persistenz im Mitfahr-Backend: Du ordnest Java- und Datenbankbegriffe zu, liest das von Hibernate erzeugte SQL für die Tabelle der Mitfahrgesuche, schreibst die Entity Gesuch, ein Repository und die Startdaten in data.sql, deutest eine Fehlermeldung zum Fremdschlüssel, machst die Beziehung zwischen Nutzer und Gesuch in beide Richtungen navigierbar und zeigst, warum EnumType.ORDINAL gespeicherte Daten unbemerkt verfälscht.

Übungsaufgaben zu REST-API und Fehlerbehandlung: Gesuche über die API einstellen

Übungen zur Fehlerbehandlung im Mitfahr-Backend: Du ordnest Fehlersituationen rund um Mitfahrgesuche den Statuscodes zu, liest eine Fehlerantwort nach RFC 9457, schreibst einen GesuchMapper und einen GesuchController, findest heraus, warum der Flurmonitor mit Gesuchen plötzlich 500 meldet, und bewertest einen Vorschlag, den Statuscode in die fachlichen Ausnahmen zu verlagern.

Ü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.

Daten speichern mit Spring Data JPA: Entities, Beziehungen, Repositories und H2

Bisher stehen die Haltepunkte fest im Code, und neue Angebote verschwinden beim Neustart. Jetzt bekommt das Mitfahr-Backend eine Datenbank: Aus dem Fachmodell werden JPA-Entities mit Beziehungen, Spring Data erzeugt den Zugriff aus einem leeren Interface, Hibernate legt die Tabellen an, und eine data.sql füllt die H2-Datenbank beim Start mit den Daten des Szenarios. Wer Docker nutzt, startet dieselbe Anwendung mit MariaDB.

Übungsaufgaben zur Build-Qualität und CI-Pipeline: Prüfregeln und Abdeckung für Mitfahrgesuche

Übungen zur Qualitätssicherung im Build des Mitfahr-Backends: Du ordnest Werkzeuge und Pipeline-Begriffe zu, deutest Checkstyle-Meldungen zur Zeitfensterregel der Mitfahrgesuche, liest Anweisungs- und Zweigabdeckung aus einem JaCoCo-Bericht ab, ergänzt eine Regel gegen „magische Zahlen“, passt die GitLab-Pipeline an und zeigst, warum 100 % Abdeckung einen Fehler an der Grenze nicht findet.

Qualität im Build und eine CI-Pipeline: Checkstyle, Spotless, JaCoCo und GitLab CI

Tests helfen nur, wenn sie auch laufen. Der Build des Mitfahrlabors bekommt drei Prüfwerkzeuge: Checkstyle prüft Regeln für den Code, Spotless sorgt für einheitliche Formatierung, JaCoCo misst die Testabdeckung. Alle hängen an der Sammelaufgabe check (Gradle) bzw. der Phase verify (Maven). Eine Pipeline in GitLab CI führt bei jedem Push die Stufen build, test, quality und package aus und zeigt Testergebnisse und Abdeckung im Merge Request.

Ü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.

Vom Vertrag zum Code: Schnittstellen mit dem OpenAPI Generator erzeugen

Der OpenAPI Generator macht aus dem API-Vertrag Java-Schnittstellen und Datenklassen. Du bindest ihn in Gradle oder Maven ein, lässt den Controller für die Haltepunkte die erzeugte Schnittstelle implementieren und siehst, wie die Regeln aus dem Vertrag als Bean Validation fehlerhafte Anfragen mit 400 abweisen. Weicht der Code vom Vertrag ab, merkt es der Compiler; ist der Vertrag fehlerhaft, bricht der Build ab.

Das Projekt anlegen: der erste Endpunkt für das Mitfahrlabor-Backend

Mit dem Spring Initializr entsteht das Projekt für das Mitfahrlabor-Backend. Du lernst die Projektstruktur, den Build mit Gradle oder Maven und die Startklasse kennen, schreibst den ersten REST-Controller für die Haltepunkte von Hand, rufst ihn mit dem Browser, einer .http-Datei oder der Shell auf und lässt den ersten Test laufen: einen Smoke-Test, der prüft, ob die Anwendung überhaupt startet.

Übungsaufgaben zu Anforderungen und API-Vertrag: Mitfahrgesuche planen

Das MVP der Mitfahr-App kennt nur Angebote. In diesen Übungen planst Du die Ressource „Gesuch“ für alle, die kein Auto haben: Du ordnest Entwurf und Test im V-Modell zu, wählst Methoden und Statuscodes, schreibst User Story und Abnahmekriterien, entwirfst Endpunkte und Schemas im OpenAPI-Vertrag, findest Fehler in einem Vertragsausschnitt und zeichnest die Zustände eines Gesuchs.

Vom Auftrag zur API: Anforderungen und OpenAPI-Vertrag für das Mitfahrlabor-Backend

Bevor die erste Zeile Java entsteht, wird geplant: Aus dem Auftrag werden User Stories mit Abnahmekriterien, aus den Fachregeln ein Fachmodell mit Zustandsdiagramm, aus der Architektur ein Schichtenmodell und aus allem zusammen ein API-Vertrag im Format OpenAPI. Damit ist die linke Seite des V-Modells für das Mitfahrlabor-Backend vollständig, und jede spätere Testebene weiß, wogegen sie prüft.

Übungsaufgaben zu „Vom Entwurf zum Code“

Zwei Übungsaufgaben zum Weg vom Entwurf zum Code: Du schneidest die CSB-Rad-Kata nach einem Paketdiagramm in Pakete, findest und löst einen Abhängigkeitszyklus, zeichnest das Klassendiagramm vorher und nachher und sicherst die Paketgrenzen mit einem Architekturtest. Danach vergleichst Du in der App Let’s Meet einen Entwurf mit dem Code, bewertest die Abweichungen und nimmst Stellung, wie viel vor der nächsten Funktion entworfen werden soll.

Vom Entwurf zum Code: Design before Implementation, Implementation reflects Design, Modularisierung und YAGNI

Wann wird entworfen, wie viel, und wie bleibt der Code dem Entwurf treu? Der Artikel stellt die Entwurfsprinzipien der Clean-Code-Developer-Initiative vor und wägt sie gegen YAGNI ab („just enough design“). Er unterscheidet iteratives und inkrementelles Entwickeln und zeigt Modularisierung mit Paketen: Du schneidest die CSB-Rad-Kata nach einem Paketdiagramm, löst einen Abhängigkeitszyklus auf, sicherst die Paketgrenzen mit einem Architekturtest und schaust auf den Übergang zu Schichten und MVC.

SOLID im Überblick: fünf Prinzipien und die Dependency Inversion

SOLID fasst fünf Entwurfsprinzipien für objektorientierten Code zusammen: Single Responsibility, Open Closed, Liskov Substitution, Interface Segregation und Dependency Inversion. Ausführlich behandelt der Artikel das letzte: Du baust in der CSB-Rad-Kata den Bestellabschluss so um, dass er nur noch von Abstraktionen abhängt, unterscheidest Dependency Inversion, Inversion of Control und Dependency Injection und testest mit Stub und Mock. Zum Schluss findest Du mehrere Verstöße zugleich und legst fest, was Du zuerst umbaust.

Klassen schneiden: Single Responsibility, Separation of Concerns, Information Hiding, Tell, don’t ask und Law of Demeter

Eine Klasse, die rechnet, prüft, Mails verschickt und speichert, muss sich bei jeder Regeländerung mitändern. Du lernst, Klassen nach Verantwortungen zu schneiden (Single Responsibility Principle), Belange zu trennen (Separation of Concerns), Entwurfsentscheidungen zu verbergen (Information Hiding), Entscheidungen zu den Daten zu verlagern (Tell, don’t ask) und Getter-Ketten aufzulösen (Law of Demeter). Am Bestellabschluss der CSB-Rad-Kata beurteilst Du Kohäsion und Kopplung im UML-Klassendiagramm.

Methoden gliedern: Single Level of Abstraction, IOSP, eine Aufgabe je Methode und Fail fast

Eine gut gegliederte Methode liest sich wie ein Inhaltsverzeichnis: oben steht, was passiert, weiter unten, wie es passiert. Du lernst, Abstraktionsebenen in einer Methode zu erkennen und zu trennen (Single Level of Abstraction), Methoden in Integrationen und Operationen aufzuteilen (IOSP), jeder Methode genau eine Aufgabe zu geben, Parameterlisten kurz zu halten und Eingaben früh zu prüfen (Fail fast, Guard Clauses, Ausnahmen statt Fehlercodes). Am Bestellabschluss der CSB-Rad-Kata siehst Du, wie sich dadurch Methodenlänge, Verschachtelung und zyklomatische Komplexität verändern.

Übungsaufgaben zu SOLID und Dependency Inversion

Drei Übungsaufgaben zu SOLID: Du entkoppelst in der CSB-Rad-Kata den Bestellabschluss nach dem Dependency Inversion Principle und testest ihn mit Stub und Mock, findest im Erinnerungsdienst des Mitfahrlabors Verstöße gegen mehrere SOLID-Prinzipien, legst eine Reihenfolge für den Umbau fest und baust ihn mit fester Uhr im Test um, und nimmst Stellung zu der Frage, wann Dependency Injection zu viel ist.

Übungsaufgaben zum Erweitern statt Ändern: Open Closed Principle und Interface Segregation Principle

Drei Übungsaufgaben zum Erweitern statt Ändern: Du ersetzt im Mitfahrlabor eine Fallunterscheidung nach dem Fahrzeugtyp durch Polymorphie, baust in der CSB-Rad-Kata die Versandarten als Strategie um und ergänzt das Expresspaket, ohne den Bestellabschluss zu ändern, und teilst ein zu breites Interface des Mitfahrlabors nach den Rollen seiner Nutzenden auf, mit Klassendiagramm vor und nach dem Umbau.

Erweitern statt ändern: Open Closed Principle und Interface Segregation Principle

Jede neue Versandart verlangt im Bestellabschluss der CSB-Rad-Kata Änderungen an mehreren switch-Anweisungen. Mit dem Open Closed Principle kommen neue Varianten als neue Klassen dazu, ohne fertigen Code zu ändern: Fallunterscheidungen nach dem Typ werden zu Polymorphie mit einer Strategie hinter einem Interface. Das Interface Segregation Principle hält diese Interfaces schlank, was vor allem Tests mit Test-Doubles erleichtert. Du lernst auch, wann sich die Abstraktion nicht lohnt (YAGNI).

Übungsaufgaben zum Einsatz von Vererbung: Liskov Substitution Principle und Favour Composition over Inheritance

Drei Übungsaufgaben zum Einsatz von Vererbung: Du findest im Mitfahrlabor LSP-Verstöße bei den Benachrichtigungskanälen und behebst sie, baust in der CSB-Rad-Kata die Kurierzustellung ohne LSP-Verstoß ein und ersetzt eine Vererbungshierarchie aus Fahrtangebot, Mitfahrerliste und ArrayList durch Komposition, mit Klassendiagramm vor und nach dem Umbau.

Vererbung richtig einsetzen: Liskov Substitution Principle und Favour Composition over Inheritance

Vererbung spart Tipparbeit, kann aber Programme brechen, die mit der Oberklasse rechnen. Das Liskov Substitution Principle sagt, wann eine Unterklasse ihre Oberklasse ersetzen kann: Sie verlangt nicht mehr, verspricht nicht weniger und hält die Invarianten ein. Du erkennst typische Verstöße und die fragile Basisklasse und ersetzt Vererbung durch Komposition und Delegation, am Beispiel der Kurierzustellung der CSB-Rad-Kata und mit Blick auf Duck Typing in Python.

Übungsaufgaben zum Schneiden von Klassen: Single Responsibility, Separation of Concerns, Information Hiding, Tell, don’t ask und Law of Demeter

Vier Übungsaufgaben zum Schneiden von Klassen: Du zerlegst die Klasse Shop der CSB-Rad-Kata in Klassen mit je einer Verantwortung, löst im Mitfahrlabor Getter-Ketten mit Tell, don’t ask auf, zeichnest für die Fahrtenverwaltung ein Klassendiagramm vor und nach dem Umbau und trennst die Anzeige der Flurmonitore in Speicherung, Fachlogik, Darstellung und Protokollierung.