In verteilten Systemen müssen Komponenten über externe Schnittstellen kommunizieren. Consumer-driven Contracts stellen einen speziellen Fall von Integrationstests dar. Sie ermöglichen es, bereits in der Entwicklung Schnittstellenverträge abzusichern, ohne dabei die beteiligten Services starten und End-to-end-Tests durchführen zu müssen. Für Spring-Entwickler stehen mit Pact JVM und Spring Cloud Contract gleich zwei Frameworks zur Verfügung, um solche Tests umzusetzen. Dieser Artikel soll bei der Entscheidung helfen, welches Framework man einsetzen möchte.
Das Ziel von Microservices ist, die Gesamtfunktionalität eines komplexen Systems in möglichst unabhängige Services aufzuteilen. Verglichen mit einem Monolithen möchte man dadurch Ziele wie ein schnelleres Deployment einzelner Services oder eine bessere und striktere Modularisierung des Systems erreichen. Da man es mit einem verteilten System zu tun hat, gehen diese Vorteile mit einer größeren technischen Komplexität einher. Einen Aspekt davon stellt die Kommunikation der Services untereinander über externe Schnittstellen wie REST APIs oder asynchrone Nachrichten dar.
Durch die externen Grenzen der Services untereinander sind Probleme beim Nutzen und Anbieten von Schnittstellen vorprogrammiert. So können z. B. neue Pflichtheader oder Parameter in einem REST Call dazukommen, welche die Schnittstelle brechen. Oft bemerken Konsumenten das erst spät, etwa bei End-to-end-Tests oder vielleicht sogar erst in der Produktion. Um die Entwicklung abzusichern, können Konsumenten das Verhalten einer Schnittstelle anhand von Mocks nachbilden und in Tests integrieren [1]. Dadurch wird sichergestellt, dass der Konsument (Consumer) den Dienst korrekt aufruft. Allerdings erfordert das, dass die Mocks aktuell gehalten werden. Die Tests müssen sich ebenfalls am Anbieter der Schnittstelle (Producer) und dessen Änderungen orientieren. Wird der Producer durch ein anderes Team bereitgestellt, kann dies das Aktuellhalten der Tests wegen geringerer direkter Kommunikation weiter erschweren.
Der Anspruch von Consumer-driven Contracts (CDC) ist, diese Lücke zwischen Consumer und Producer zu schließen, indem die Konsumenten dem Anbieter ihre Erwartungen in Form von Verträgen mitteilen. Dabei sind Verträge nicht im Sinne vollständiger Schnittstellenbeschreibungen (z. B. als WDSL) zu verstehen, sondern als minimale Anforderung eines Clients an einen API-Provider. Während der Anbieter eines API in der Regel Anforderungen mehrerer Clients befriedigen muss, sind diese nicht unbedingt daran interessiert, die komplette Schnittstelle zu kennen; oft reicht ein Ausschnitt eines JSON-Dokuments. Der Consumer-driven-Ansatz ist daher nur in Umfeldern interessant, in denen APIs parallel mit den Anforderungen der Konsumenten entwickelt werden.
Im Vorgehensmodell von CDC implementiert der Konsument zuerst gegen die zu definierende externe Schnittstelle und macht die daraus resultierende Anforderung dem Providerteam zugänglich. Der Konsument schreibt außerdem Tests, die die korrekte Verwendung des Vertrags durch den Consumer überprüfen. Clientseitig ist dieses Vorgehen identisch mit dem Testen gegen einen Mock-Server wie z. B. WireMock, der auf Aufrufe mit Stubs der externen Schnittstelle antwortet. Bei CDCs kommt nun aber hinzu, dass der Producer den Vertrag ebenfalls in Unit-Tests integriert. Diese vergleichen die Rückgabewerte der Schnittstelle mit der Erwartung des Vertrags. Erst wenn beide Tests erfolgreich sind, ist der Vertrag vollständig verifiziert. Weichen Werte auf der Providerseite ab oder hat sich die Verwendung der Schnittstelle auf Clientseite geändert, schlagen die Tests auf einer oder beiden Seiten fehl. Schnittstelle und ggf. Logik müssen angepasst werden. Somit hat man die Tests zweier unabhängiger Services miteinander integriert, ohne dass diese direkt miteinander kommunizieren müssen.
Contract-Tests erhöhen also die Sicherheit zur Entwicklungszeit, da Fehler bei der formalen Verwendung der Schnittstellen schnell sichtbar werden und dann behoben werden können. Eine komplette Integration mit anderen Services ist an dieser Stelle nicht nötig. Contract-Tests können allerdings keine End-to-end-Tests ersetzen. Sie können als Integrationstests im Sinne der fowlerschen Testpyramide gesehen werden, deren Grenze zum (gemockten) externen System hin verläuft. Sie berücksichtigen daher auch nicht, ob die Daten der Stubs den realen Daten eines Produktivsystems entsprechen. Hierfür sind natürlich nach wie vor z. B. End-to-end-REST-API-Tests, UI-Tests oder Acceptance-Tests erforderlich [2].
Pact JVM [3] und Spring Cloud Contract (SCC) [4] sind zwei Frameworks, die CDC in der Java-Welt unterstützen. Dieser Artikel stellt diese Frameworks kurz vor und zeigt, wie man mit ihnen Tests in einer Spring-Anwendung schreibt. Der Artikel möchte eine etwas umfassendere Darstellung bieten und behandelt neben REST-API-Contract-Tests (über die bereits eine Reihe von Artikeln und Blogeinträgen existiert) auch Messaging-Schnittstellen. Dabei beschränken sich – bedingt durch das Kundenprojekt des Autors – Darstellung und Bewertung der Alternativen auf die Anwendung des jeweiligen Frameworks in einer Spring-Microservices-Landschaft. Als Beispiel dienen drei Microservices eines fiktiven Onlinebuchshops (das Beispiel ist auf GitHub verfügbar [5]:
Ein Client-Service, der Anfragen von außen entgegennimmt und auf zwei interne Services weiterverteilt
Ein Catalog Service für das Abrufen von Büchern mittels REST-Schnittstelle
Ein Order Service für das Bestellen von Büchern über eine Messaging-Schnittstelle
Beispielanwendungsfall
Der Beispielclient steht exemplarisch für den Aufruf sowohl eines REST API als auch einer AMQP-Schnittstelle. Im REST-Fall wird eine einfache GET-Anfrage an den Catalog Service gestellt, um eine Liste von Büchern abzurufen; im Messaging-Fall wird ein BookOrderedEvent empfangen, nachdem ein Buch bestellt wurde. Diese über AMQP versendete Nachricht wird dabei von Spring bereits in ein BookOrderedEvent umgewandelt und dem RabbitListener übergeben. Listing 1 zeigt den REST-Client und den Message Listener der Beispielanwendung. Abbildung 1 stellt schematisch den Ablauf von Consumer-driven-Contracts-Tests, abstrahiert vom jeweiligen Framework, für die beiden Fälle des Anwendungsbeispiels dar.
Listing 1
@Service
public class BookRestUpstreamService {
private final RestTemplate restTemplate;
public List<Book> getAllBooks() {
String url = "http://localhost:8087/books";
return Arrays.asList(restTemplate.exchange(url, HttpMethod.GET, createHeaders(), Book[].class).getBody());
}
...
}
@Service
public class BookOrderedEventRabbitListener {
private final BookService bookService;
@RabbitListener(queues = "order-queue")
public void receiveMessage(BookOrderedEvent event) {
bookService.orderConfirmed(event);
}
}
Abb. 1: Schematische Darstellung von CDC anhand der BeispielanwendungPact
Ursprünglich in und für Ruby umgesetzt, existiert neben unterschiedlichen Implementierungen mit Pact JVM auch eine Variante, die auf der JVM nutzbar ist und einen JUnit Runner sowie Gradle- und Maven-Plug-ins zur Verfügung stellt. Darüber hinaus gibt es Spring-Erweiterungen, die eine Integration in Spring-Boot-Tests ermöglichen. Pact unterstützt CDC für REST-Schnittstellen ebenso wie für Messaging-Schnittstellen.
Ein Contract-Test wird in folgenden Schritten umgesetzt: Auf der Consumer-Seite wird in einem ersten Schritt der Vertrag per DSL definiert und in einem zweiten Testschritt verifiziert. In diesem Schritt wird ein Mock-Server gestartet, der auf Anfragen mit den vorher definierten Antworten reagiert. Ein Server kann hierbei ein Mock-HTTP-Server oder ein Mock-AMQP-Server sein. Während der Ausführung des Tests wird eine Pact-Datei generiert und in Form eines JSON-Dokuments auf das Dateisystem geschrieben. Ein Verifikationsschritt ist also immer erforderlich, da nur so sichergestellt wird, dass der definierte Vertrag auch tatsächlich den Anforderungen des Clients gerecht wird (sonst könnte der Vertrag beliebig sein). Die Pact-Datei kann nun dem Producer übergeben werden, der dann die tatsächliche Antwort mit der erwarteten vergleichen kann. Die folgenden Abschnitte beschreiben diese Schritte im Detail.
Pact-Consumer-Test
Das Schreiben des Tests erfolgt unter Verwendung von pact-jvm-consumer-junit-Maven- oder Gradle-Plug-ins. Listing 2 zeigt den vereinfachten Test für einen REST-API-Vertrag.
Listing 2
public class BookCatalogConsumerPactTest {
@Rule
public PactProviderRuleMk2 mockProvider =
new PactProviderRuleMk2("book-catalog-service", "localhost", 8081, this);
@Pact(consumer="books-client-catalog-rest-consumer")
public RequestResponsePact pact(PactDslWithProvider builder) {
DslPart payload = new PactDslJsonArray()
.object()
.integerType("id")
.stringType("authorFirstName");
return builder
.given("get")
.uponReceiving("A successful api GET call")
.path("/books")
.headers(expectedRequ...
