Testcontainers

The Testcontainers library provides a way to manage services running inside Docker containers. It integrates with JUnit, allowing you to write a test class that can start up a container before any of the tests run. Testcontainers is especially useful for writing integration tests that talk to a real backend service such as MySQL, MongoDB, Cassandra and others.spring-doc.cn

Testcontainers can be used in a Spring Boot test as follows:spring-doc.cn

import org.junit.jupiter.api.Test;
import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import org.springframework.boot.test.context.SpringBootTest;

@Testcontainers
@SpringBootTest
class MyIntegrationTests {

	@Container
	static Neo4jContainer<?> neo4j = new Neo4jContainer<>("neo4j:5");

	@Test
	void myTest() {
		// ...
	}

}
import org.junit.jupiter.api.Test;
import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.testcontainers.service.connection.ServiceConnection

@Testcontainers
@SpringBootTest
class MyIntegrationTests {

	@Test
	fun myTest() {
		// ...
	}

	companion object {
		@Container
		@JvmStatic
		val neo4j = Neo4jContainer("neo4j:5");
	}
}

This will start up a docker container running Neo4j (if Docker is running locally) before any of the tests are run. In most cases, you will need to configure the application to connect to the service running in the container.spring-doc.cn

Service Connections

A service connection is a connection to any remote service. Spring Boot’s auto-configuration can consume the details of a service connection and use them to establish a connection to a remote service. When doing so, the connection details take precedence over any connection-related configuration properties.spring-doc.cn

When using Testcontainers, connection details can be automatically created for a service running in a container by annotating the container field in the test class.spring-doc.cn

import org.junit.jupiter.api.Test;
import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.testcontainers.service.connection.ServiceConnection;

@Testcontainers
@SpringBootTest
class MyIntegrationTests {

	@Container
	@ServiceConnection
	static Neo4jContainer<?> neo4j = new Neo4jContainer<>("neo4j:5");

	@Test
	void myTest() {
		// ...
	}

}
import org.junit.jupiter.api.Test;
import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.testcontainers.service.connection.ServiceConnection;

@Testcontainers
@SpringBootTest
class MyIntegrationTests {

	@Test
	fun myTest() {
		// ...
	}

	companion object {

		@Container
		@ServiceConnection
		@JvmStatic
		val neo4j = Neo4jContainer("neo4j:5");

	}

}

Thanks to @ServiceConnection, the above configuration allows Neo4j-related beans in the application to communicate with Neo4j running inside the Testcontainers-managed Docker container. This is done by automatically defining a Neo4jConnectionDetails bean which is then used by the Neo4j auto-configuration, overriding any connection-related configuration properties.spring-doc.cn

You’ll need to add the spring-boot-testcontainers module as a test dependency in order to use service connections with Testcontainers.

Service connection annotations are processed by ContainerConnectionDetailsFactory classes registered with spring.factories. A ContainerConnectionDetailsFactory can create a ConnectionDetails bean based on a specific Container subclass, or the Docker image name.spring-doc.cn

The following service connection factories are provided in the spring-boot-testcontainers jar:spring-doc.cn

Connection Details Matched on

ActiveMQConnectionDetailsspring-doc.cn

Containers named "symptoma/activemq" or ActiveMQContainerspring-doc.cn

ArtemisConnectionDetailsspring-doc.cn

Containers of type ArtemisContainerspring-doc.cn

CassandraConnectionDetailsspring-doc.cn

Containers of type CassandraContainerspring-doc.cn

CouchbaseConnectionDetailsspring-doc.cn

Containers of type CouchbaseContainerspring-doc.cn

ElasticsearchConnectionDetailsspring-doc.cn

Containers of type ElasticsearchContainerspring-doc.cn

FlywayConnectionDetailsspring-doc.cn

Containers of type JdbcDatabaseContainerspring-doc.cn

JdbcConnectionDetailsspring-doc.cn

Containers of type JdbcDatabaseContainerspring-doc.cn

KafkaConnectionDetailsspring-doc.cn

Containers of type KafkaContainer, ConfluentKafkaContainer or RedpandaContainerspring-doc.cn

LiquibaseConnectionDetailsspring-doc.cn

Containers of type JdbcDatabaseContainerspring-doc.cn

MongoConnectionDetailsspring-doc.cn

Containers of type MongoDBContainerspring-doc.cn

Neo4jConnectionDetailsspring-doc.cn

Containers of type Neo4jContainerspring-doc.cn

OtlpLoggingConnectionDetailsspring-doc.cn

Containers named "otel/opentelemetry-collector-contrib" or of type LgtmStackContainerspring-doc.cn

OtlpMetricsConnectionDetailsspring-doc.cn

Containers named "otel/opentelemetry-collector-contrib" or of type LgtmStackContainerspring-doc.cn

OtlpTracingConnectionDetailsspring-doc.cn

Containers named "otel/opentelemetry-collector-contrib" or of type LgtmStackContainerspring-doc.cn

PulsarConnectionDetailsspring-doc.cn

Containers of type PulsarContainerspring-doc.cn

R2dbcConnectionDetailsspring-doc.cn

Containers of type ClickHouseContainer, MariaDBContainer, MSSQLServerContainer, MySQLContainer, OracleContainer (free), OracleContainer (XE) or PostgreSQLContainerspring-doc.cn

RabbitConnectionDetailsspring-doc.cn

Containers of type RabbitMQContainerspring-doc.cn

RedisConnectionDetailsspring-doc.cn

Containers of type RedisContainer or RedisStackContainer, or containers named "redis", "redis/redis-stack" or "redis/redis-stack-server"spring-doc.cn

ZipkinConnectionDetailsspring-doc.cn

Containers named "openzipkin/zipkin"spring-doc.cn

By default all applicable connection details beans will be created for a given Container. For example, a PostgreSQLContainer will create both JdbcConnectionDetails and R2dbcConnectionDetails.spring-doc.cn

If you want to create only a subset of the applicable types, you can use the type attribute of @ServiceConnection.spring-doc.cn

By default Container.getDockerImageName().getRepository() is used to obtain the name used to find connection details. The repository portion of the Docker image name ignores any registry and the version. This works as long as Spring Boot is able to get the instance of the Container, which is the case when using a static field like in the example above.spring-doc.cn

If you’re using a @Bean method, Spring Boot won’t call the bean method to get the Docker image name, because this would cause eager initialization issues. Instead, the return type of the bean method is used to find out which connection detail should be used. This works as long as you’re using typed containers such as Neo4jContainer or RabbitMQContainer. This stops working if you’re using GenericContainer, for example with Redis as shown in the following example:spring-doc.cn

import org.testcontainers.containers.GenericContainer;

import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
import org.springframework.context.annotation.Bean;

@TestConfiguration(proxyBeanMethods = false)
public class MyRedisConfiguration {

	@Bean
	@ServiceConnection(name = "redis")
	public GenericContainer<?> redisContainer() {
		return new GenericContainer<>("redis:7");
	}

}
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.boot.testcontainers.service.connection.ServiceConnection
import org.springframework.context.annotation.Bean
import org.testcontainers.containers.GenericContainer

@TestConfiguration(proxyBeanMethods = false)
class MyRedisConfiguration {
	@Bean
	@ServiceConnection(name = "redis")
	fun redisContainer(): GenericContainer<*> {
		return GenericContainer("redis:7")
	}
}

Spring Boot can’t tell from GenericContainer which container image is used, so the name attribute from @ServiceConnection must be used to provide that hint.spring-doc.cn

You can also use the name attribute of @ServiceConnection to override which connection detail will be used, for example when using custom images. If you are using the Docker image registry.mycompany.com/mirror/myredis, you’d use @ServiceConnection(name="redis") to ensure RedisConnectionDetails are created.spring-doc.cn

Dynamic Properties

A slightly more verbose but also more flexible alternative to service connections is @DynamicPropertySource. A static @DynamicPropertySource method allows adding dynamic property values to the Spring Environment.spring-doc.cn

import org.junit.jupiter.api.Test;
import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;

@Testcontainers
@SpringBootTest
class MyIntegrationTests {

	@Container
	static Neo4jContainer<?> neo4j = new Neo4jContainer<>("neo4j:5");

	@Test
	void myTest() {
		// ...
	}

	@DynamicPropertySource
	static void neo4jProperties(DynamicPropertyRegistry registry) {
		registry.add("spring.neo4j.uri", neo4j::getBoltUrl);
	}

}
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.DynamicPropertyRegistry
import org.springframework.test.context.DynamicPropertySource
import org.testcontainers.containers.Neo4jContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers

@Testcontainers
@SpringBootTest
class MyIntegrationTests {

	@Test
	fun myTest() {
		// ...
	}

	companion object {
		@Container
		@JvmStatic
		val neo4j = Neo4jContainer("neo4j:5");

		@DynamicPropertySource
		@JvmStatic
		fun neo4jProperties(registry: DynamicPropertyRegistry) {
			registry.add("spring.neo4j.uri") { neo4j.boltUrl }
		}
	}
}

The above configuration allows Neo4j-related beans in the application to communicate with Neo4j running inside the Testcontainers-managed Docker container.spring-doc.cn