Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

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:


Next, let's add the Testcontainers 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:


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:

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:

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:

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:

void givenProductCreated_whenGettingProductById_thenProductExistsAndHasSameProperties() {
    Product product = new Product("1", "Test Product", 10.0);
    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);

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);
    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.

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.

As always, the source code for the examples can be found over on GitHub.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


Junit footer banner
Inline Feedbacks
View all comments
Comments are closed on this article!