© chuyuss/Shutterstock.com
Testcontainers, JUnit 5 und Vaadin

Docker dir einen


Docker hier, Docker da, am besten gleich als Kubernetes-Cluster. Das ist für diejenigen, die sich in der Zukunft mit den Großen messen wollen. Man weiß ja nie, wie schnell man skalieren muss und Milliardär wird. Aber da gibt es noch den Rest, der mit den ganz gewöhnlichen Szenarien klarkommen muss. Keine Sorge, dieser Artikel ist keine Einführung in Docker.

Seien wir bescheiden und nehmen an, dass wir nur ein paar Docker-Container benötigen, um unsere Herausforderungen zu meistern. Docker als Basis zu nehmen, wenn man mit verschiedenen Systemen eine Komposition aufbauen muss, ist eine rundweg solide Entscheidung. Schnell ist der Downloadlink gefunden und dank unserer hervorragenden Internetinfrastruktur findet man sich schnell als stolzer Docker-Installateur wieder. Ein paar Klicks auf die richtige Stelle am Bildschirm und schon läuft die Basisinfrastruktur.

Und jetzt? Ja, jetzt kommt der lästige Teil, die Verwendung von Docker selbst. Aber wollte man eigentlich nicht nur mal eben eine Datenbank in einer PostgreSQL-Instanz ausprobieren?

Der manuelle Weg könnte dann so aussehen: Nachdem der Befehl docker pull postgres auf der Kommandozeile ausgeführt worden ist, befindet sich das Image auf dem lokalen Rechner und ist bereit, gestartet zu werden. Ein docker run --name some-postgres -e POSTGRES_PASSWORD=mysecretpassword -d postgres erzeugt dann einen Container, startet ihn und setzt das Passwort auf mysecretpassword. Ein docker ps zeigt, dass der Container läuft. Voller Optimismus startet man nun das SQL-Werkzeug seiner Wahl und möchte sich zu der frisch geschlüpften PostgreSQL verbinden. Und hier beginnt auch schon das Dilemma.

Eine Verbindung à la jdbc:postgresql://localhost:5432/postgres funktioniert nicht. Da war doch noch was? Genau, die Ports sind nicht nach draußen freigegeben. Und so geht das dann erst einmal weiter. Nachdem man alles im Internet zusammengesucht hat, stellt sich die Frage, wie man alle Kommandos so in das Projekt einbinden kann, dass es unfallfrei verwendbar ist. Und dann war da noch das Dilemma mit der CI-Strecke.

Testcontainers

Da man mit diesen Herausforderungen nicht allein auf der Welt ist, besteht die Chance, dass dieses Problem schon andere so richtig genervt hat und daraus Lösungen entstanden sind. Eine dieser möglichen Lösungen ist das Projekt Testcontainers. Als Erstes müssen dem Projekt die notwendigen Abhängigkeiten hinzugefügt werden. Wird Maven verwendet, kann das folgendermaßen aussehen:

<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>testcontainers</artifactId>
  <version>1.10.6</version>
  <scope>test</scope>
</dependency>

Möchte man nun einen Docker-Container starten, kann man mit der Klasse GenericContainer beginnen. Der Konstruktor erwartet den Namen eines Image, in unserem Fall postgres. Da die Klasse das Interface Autoclosable implementiert, ist ein explizites stop() nicht notwendig, um den Container wieder ordnungsgemäß zu beenden:

try (GenericContainer container = new GenericContainer("postgres")) {
  container.start();
  // ... use the container
  // no need to call stop() afterwards
}

Wenn man das nun innerhalb einer main-Methode startet, bekommt man etwa die in Listing 1 gezeigten Meldungen zu sehen.

Listing 1

```bash
[main] INFO org.testcontainers.dockerclient.DockerClientProviderStrategy - Loaded org.testcontainers.dockerclient.UnixSocketClientProviderStrategy from ~/.testcontainers.properties, will try it first
[main] INFO org.testcontainers.dockerclient.DockerClientProviderStrategy - Will use 'okhttp' transport
[main] INFO org.testcontainers.dockerclient.UnixSocketClientProviderStrategy - Accessing docker with local Unix socket
[main] INFO org.testcontainers.dockerclient.DockerClientProviderStrategy - Found Docker environment with local Unix socket (unix:///var/run/docker.sock)
[main] INFO org.testcontainers.DockerClientFactory - Docker host IP address is localhost
[main] INFO org.testcontainers.DockerClientFactory - Connected to docker: 
  Server Version: 18.09.2
  API Version: 1.39
  Operating System: Docker for Mac
  Total Memory: 1998 MB
[main] INFO org.testcontainers.utility.RegistryAuthLocator - Credentials not found for host (quay.io) when using credential helper/store (docker-credential-osxkeychain)
[main] INFO org.testcontainers.DockerClientFactory - Ryuk started - will monitor and terminate Testcontainers containers on JVM exit
         Checking the system...
         Docker version should be at least 1.6.0
         Docker environment should have more than 2GB free disk space
[main] INFO [postgres:latest] - Creating container for image: postgres:latest
[main] INFO [postgres:latest] - Starting container with ID: 56e82d812e89dd0c8017c2d52989e4a0005f818a2072f6d6355012b66dee7b18
[main] INFO [postgres:latest] - Container postgres:latest is starting: 56e82d812e89dd0c8017c2d52989e4a0005f818a2072f6d6355012b66dee7b18
[main] INFO [postgres:latest] - Container postgres:latest started
```

Sobald der Container gestartet wird, werden einige notwendige Rahmenparameter überprüft. Ist das angegebene Image nicht auf dem Zielsystem vorhanden, wird es automatisch nachgeladen. Da wir zu Beginn den PostgreSQL-Container einmal auf der Kommandozeile per Hand gestartet haben, war das in diesem Fall nicht mehr notwendig.

PostgreSQL-Container

Allerdings haben wir hiermit nur die halbe Strecke geschafft. Auch hier muss man sich mit dem Container und dessen Konfiguration auseinandersetzen. Das Ziel ist ja immer noch, einen PostgreSQL-Container so zu starten, dass wir Zugriff auf das RDBMS haben. Testcontainers liefert für einige RDBMS vorgefertigte Klassen. Für PostgreSQL wird die Klasse PostgreSQLContainer eingesetzt. Der Ablauf ist aber genauso wie vorher beim generischen Container (Listing 2).

Listing 2

public static void main(String[] args) {
  try (PostgreSQLContainer container = new PostgreSQLContainer()
                                           .withDatabaseName("foo")
                                           .withUsername("foo")
                                           .withPassword("secret")) {
    container
        .start();
 
    final String jdbcUrl = container.getJdbcUrl();
    System.out.println("jdbcUrl = " + jdbcUrl);
    // ... use the container
    // no need to call stop() afterwards
  }
}

Was hier ebenfalls mitgeliefert wird, sind Methoden, die den Umgang mit dem RDBMS erleichtern. So findet man die Methoden zum Setzen des Benutzernamens, Passworts und Datenbanknamens. Um sich später mittels JDBC mit der Instanz zu verbinden, kann man sich den JDBC URL von der jeweiligen Containerinstanz geben lassen.

Der JDBC URL war in diesem Fall jdbcUrl = jdbc:postgresql://localhost:32779/foo. Was hier auffällt, ist Port 32779, der nicht der normalerweise von PostgreSQL verwendete Port ist (das ist nämlich Port 5432). Das Testcontainers-Team hat also Wert darauf gelegt, dass man ohne Mehraufwand eine beliebige Anzahl von gleichen Containern starten kann und diese sich mit den Ports nicht gegenseitig in die Quere kommen.

Nachdem die Container erzeugt, gestartet und gestoppt werden können und auch der JDBC-URL zur Verfügung steht, ist es an der Zeit, eine erste Verbindung zum System aufzubauen. Der pom.xml werden die Abhängigkeiten für den PostgreSQL-JDBC-Treiber und für einen JDBC Connection Pool hinzugefügt. Als JDBC Connection Pool kommt hier der Open-Source-Vertreter mit dem Namen Hikari zum Einsatz (Listing 3).

Listing 3

<dependency>
  <groupId>org.postgresql</groupId>
  <artifactId>postgresql</artifactId>
  <version>42.2.5</version>
</dependency>
 
<dependency>
  <groupId>com.zaxxer</groupId>
  <artifactId>HikariCP</artifactId>
  <version>3.3.1</version>
</dependency>

Um nun eine aktive Verbindung aufzubauen und die Testabfrage gegen das System zu stellen, wird zuerst ein Connection Pool erzeugt:

private static DataSource createDataSource(JdbcDatabaseContainer container) {
  HikariConfig hikariConfig = new HikariConfig();
  hikariConfig.setJdbcUrl(container.getJdbcUrl());
  hikariConfig.setUsername(container.getUsername());
  hikariConfig.setPassword(container.getPassword());
  return new HikariDataSource(hikariConfig);
}

und mit einer Verbindung aus dem Pool wird eine Test-SQL-Abfrage an das RDBMS gesendet (Listing 4).

Listing 4

private static ResultSet...

headline from sands settings