Spring Boot – Testing Redis With Testcontainers

1. Overview

Testcontainers is a Java library for creating temporary Docker containers for unit testing purposes. It’s useful when we want to avoid testing with actual servers.

In this tutorial, we’ll learn how to use Testcontainers while testing a Spring Boot application that uses Redis.

2. Project Setup

The first prerequisite to using any test container is to have Docker installed on the machine where we are running the tests.

Once we have Docker installed, we can start setting up our Spring Boot application.

In this application, we’ll set up a Redis hash, a repository, and a service that will use the repository to interact with Redis.

2.1. Dependencies

Let’s start by adding the required dependencies to our project.

Firstly, we’ll add the Spring Boot Starter Test and Spring Boot Starter Data Redis dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Next, let’s add the Testcontainers dependency:

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

2.2. Autoconfiguration

Since we don’t require any advanced configurations, we can use autoconfiguration to set up a connection to the Redis server.

For this, we need to add the Redis connection details to the application.properties file:

spring.redis.host=127.0.0.1
spring.redis.port=6379

3. Application Setup

Let’s start with the code for our main application. We’ll build a small application that reads and writes products to a Redis database.

3.1. Entity

Let’s start with the Product class:

@RedisHash("product")
public class Product implements Serializable {
    private String id;
    private String name;
    private double price;

    // Constructor, getters and setters
}

The @RedisHash annotation is used to tell Spring Data Redis that this class should be stored in a Redis hash. Saving as a hash is good for entities that don’t contain nested objects.

3.2. Repository

Next, we can define a repository for our Product hash:

@Repository
public interface ProductRepository extends CrudRepository<Product, String> {
}

The CRUD repository interface already implements the methods we need to save, update, delete and find products. So we don’t need to define any methods ourselves.

3.3. Service

Finally, let’s create a service that performs read and write operations using the ProductRepository:

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public Product getProduct(String id) {
        return productRepository.findById(id).orElse(null);
    }

    // other methods
}

This service can then be used by controllers or services to perform CRUD operations on the products.

In actual applications, these methods may contain more complex logic, but for the purposes of this tutorial, we’ll only focus on the Redis interactions.

4. Testing

We’ll now write tests for our ProductService to test the CRUD operations.

4.1. Testing the Service

Let’s write an integration test for the ProductService:

@Test
void givenProductCreated_whenGettingProductById_thenProductExistsAndHasSameProperties() {
    Product product = new Product("1", "Test Product", 10.0);
    productService.createProduct(product);
    Product productFromDb = productService.getProduct("1");
    assertEquals("1", productFromDb.getId());
    assertEquals("Test Product", productFromDb.getName());
    assertEquals(10.0, productFromDb.getPrice());
}

This assumes that a Redis database is running on the URL specified in the properties. If we don’t have a Redis instance running or our server cannot connect to it, the tests will run into errors.

4.2. Starting a Redis Container With Testcontainers

Let’s solve this problem by running a Redis test container when the tests are run. Then, we’ll change the connection details from the code itself.

Let’s look at the code to create and run the test container:

static {
    GenericContainer<?> redis = 
      new GenericContainer<>(DockerImageName.parse("redis:5.0.3-alpine")).withExposedPorts(6379);
    redis.start();
}

Let’s understand the different parts of this code:

• we have created a new container from the image redis:5.0.3-alpine
• by default, the Redis instance will run on port 6379. To expose this port, we can use the withExposedPorts() method. It’ll expose this port and map it to a random port on the host machine
• the start() method will start the container and wait for it to be ready
• we have added this code to a static code block so that it runs before the dependencies are injected, and tests are run

4.3. Changing the Connection Details

At this point, we have a Redis container running, but we haven’t changed the connection details used by the application. To do this, all we need to do is to override the connection details in the application.properties file using system properties:

static {
    GenericContainer<?> redis = 
      new GenericContainer<>(DockerImageName.parse("redis:5.0.3-alpine")).withExposedPorts(6379);
    redis.start();
    System.setProperty("spring.redis.host", redis.getHost());
    System.setProperty("spring.redis.port", redis.getMappedPort(6379).toString());
}

We’ve set the spring.redis.host property to the IP address of the container.

We can get the mapped port of port 6379 to set the spring.redis.port property.

Now when the tests run, they’ll connect to the Redis database running on the container.

4.4. Alternate Configuration for Redis Container

Alternatively, we can use the Jupiter integration through the @Testcontainers annotation to manage the lifecycle of the Redis container. When using this integration, we can use the @Container annotation to mark the containers for life-cycle management. Let’s go ahead and use this approach for configuring the Redis container for our tests.

First, we must add the junit-jupiter and testcontainers-redis-junit-jupiter dependencies in the project’s pom.xml file:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>1.17.6</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>com.redis.testcontainers</groupId>
    <artifactId>testcontainers-redis-junit-jupiter</artifactId>
    <version>1.4.6</version>
    <scope>test</scope>
</dependency>

Next, let’s define the REDIS_CONTAINER static field with the @Container annotation:

@Container
private static final RedisContainer REDIS_CONTAINER = 
  new RedisContainer(DockerImageName.parse("redis:5.0.3-alpine")).withExposedPorts(6379);

We must note that the containers defined as static fields will be shared between the test methods and started only once.

Additionally, let’s define the registerRedisProperties() method using the @DynamicPropertySource annotation to configure the connection properties for the application:

@DynamicPropertySource
private static void registerRedisProperties(DynamicPropertyRegistry registry) {
    registry.add("spring.redis.host", REDIS_CONTAINER::getHost);
    registry.add("spring.redis.port", () -> REDIS_CONTAINER.getMappedPort(6379).toString());
}

Finally, let’s validate that our configuration is working as expected:

@Test
void givenRedisContainerConfiguredWithDynamicProperties_whenCheckingRunningStatus_thenStatusIsRunning() {
    assertTrue(REDIS_CONTAINER.isRunning());
}

Perfect! We can see that the Redis container is available for test methods. Further, we don’t have to change the other test methods and can use them as they are.

5. Conclusion

In this article, we learned how to use Redis Testcontainer to run the tests. We also looked at certain aspects of Spring Data Redis to understand how to use it.