Spring Boot + DataMongoTest + Testcontainers: Testing MongoDB Repositories with a MongoDB Container

Introduction

The @DataMongoTest annotation in Spring Boot is designed for isolated testing of MongoDB repositories. By default, it configures an embedded MongoDB (Flapdoodle) for testing. However, in real-world scenarios, we might need to test against a real MongoDB instance without installing it locally.

This is where Testcontainers comes in.

What is Testcontainers?

Testcontainers is a Java library that allows running lightweight, disposable containers for databases, message queues, and other dependencies. It is particularly useful for integration testing as it provides:

Real database testing without requiring local installation.
Fresh database instances for each test execution.
Automatic cleanup of containers after tests.
Consistent testing environments across different machines.

Project Setup

To get started, create a Spring Boot project with the following dependencies:

• Spring Boot Starter Data MongoDB – For working with MongoDB.
• Spring Boot Starter Test – Provides JUnit, AssertJ, and Mockito.
• Testcontainers MongoDB – Runs MongoDB in a container.

Spring Boot Testing Libraries

The spring-boot-starter-test dependency provides several useful testing tools:

• JUnit – The core testing framework.
• Spring Boot Test – Provides utilities for integration testing.
• AssertJ – Fluent assertion library.
• Mockito – A mocking framework.
• Testcontainers – Allows running a real MongoDB database in a container.

Implementation

1. pom.xml Configuration

To use Testcontainers with MongoDB, add the necessary dependencies to pom.xml.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>tech.devblueprint</groupId>
    <artifactId>datamongodb-testcontainers-spring-boot-testing-example</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>datamongodb-testcontainers-spring-boot-testing-example</name>
    <description>Demo project for Spring Boot</description>
    <url/>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-testcontainers</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>mongodb</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Key Dependencies Explained:

• spring-boot-starter-data-mongodb – Enables MongoDB support.
• spring-boot-starter-test – Includes essential testing libraries.
• spring-boot-testcontainers – Enables Testcontainers integration with Spring Boot.
• org.testcontainers:mongodb – Runs MongoDB in a container.
• org.testcontainers:junit-jupiter – Integrates JUnit 5 with Testcontainers.

2. Configuring MongoDB Testcontainer

By default, @DataMongoTest starts an embedded MongoDB (Flapdoodle). To use a MongoDB container, we need to:

1. Start a MongoDB Testcontainer in the test class.
2. Dynamically provide the MongoDB URI to Spring Boot.

3. Document Definition

File: src/main/java/…/document/Device.java

package tech.devblueprint.datamongodb_spring_boot_testing_example.document;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "devices")
public class Device {

    @Id
    private String id;
    private String name;
    private String type;
    private String manufacturer;

    // Default constructor
    public Device() {
    }

    // Parameterized constructor
    public Device(String id, String name, String type, String manufacturer) {
        this.id = id;
        this.name = name;
        this.type = type;
        this.manufacturer = manufacturer;
    }

    // Getter and Setter for id
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }

    // Getter and Setter for name
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    // Getter and Setter for type
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }

    // Getter and Setter for manufacturer
    public String getManufacturer() {
        return manufacturer;
    }
    public void setManufacturer(String manufacturer) {
        this.manufacturer = manufacturer;
    }
}

4. Repository Interface

File: src/main/java/…/repository/DeviceRepository.java

package tech.devblueprint.datamongodb_spring_boot_testing_example.repository;

import tech.devblueprint.datamongodb_spring_boot_testing_example.document.Device;
import org.springframework.data.mongodb.repository.MongoRepository;
import java.util.Optional;

public interface DeviceRepository extends MongoRepository<Device, String> {

    // Find a device by its name
    Optional<Device> findByName(String name);

Writing Tests with Testcontainers

Using a MongoDB Container in Tests

With @DataMongoTest, we can start a MongoDB container and register its connection details dynamically.

File: src/test/java/…/repository/DeviceRepositoryTestContainersTest.java

package tech.devblueprint.datamongodb_testcontainers_spring_boot_testing_example;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MongoDBContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import tech.devblueprint.datamongodb_testcontainers_spring_boot_testing_example.document.Device;
import tech.devblueprint.datamongodb_testcontainers_spring_boot_testing_example.repository.DeviceRepository;

import static org.assertj.core.api.Assertions.assertThat;

@Testcontainers
@DataMongoTest
public class DeviceRepositoryTestContainersTest {

    // Start a MongoDB container with the latest image
    @Container
    static MongoDBContainer mongoDBContainer = new MongoDBContainer("mongo:latest");

    // Dynamically set the Spring property for MongoDB URI
    @DynamicPropertySource
    static void setProperties(DynamicPropertyRegistry registry) {
        // This provides the connection string to Spring Boot
        registry.add("spring.data.mongodb.uri", mongoDBContainer::getReplicaSetUrl);
    }

    @Autowired
    private DeviceRepository deviceRepository;

    @BeforeEach
    void setUp() {
        // Clean up database and insert test data
        deviceRepository.deleteAll();
        Device device = new Device("20", "TCDevice", "Controller", "TCManufacturer");
        deviceRepository.save(device);
    }

    @Test
    void findByName_ReturnsDevice() {
        // Test retrieval of device by name from MongoDB container
        Device device = deviceRepository.findByName("TCDevice").orElse(null);
        assertThat(device).isNotNull();
        assertThat(device.getType()).isEqualTo("Controller");
        assertThat(device.getManufacturer()).isEqualTo("TCManufacturer");
    }
}

Key Annotations Explained:

• @Testcontainers – Enables Testcontainers integration.
• @Container – Defines a MongoDB container that runs for the duration of the test class.
• @DynamicPropertySource – Registers the container’s MongoDB URI dynamically.
• @DataMongoTest – Loads only MongoDB-related components for testing.
• @BeforeEach – Cleans up the database and inserts test data before each test.
• @Test – Runs the test case for MongoDB repository methods.

Understanding Transactions in @DataMongoTest

Unlike relational databases, MongoDB does not support transactions in the same way as SQL databases. Therefore, @DataMongoTest does not roll back changes automatically.

If needed, you should manually clean up the database before each test:

@BeforeEach
void setUp() {
    deviceRepository.deleteAll();
}

Conclusion

In this guide, we explored how to use @DataMongoTest with Testcontainers to test MongoDB repositories with a real database instance.

Key Takeaways:

Testcontainers provides a real MongoDB instance without requiring local installation.
Automatically starts and stops a MongoDB database for testing.
Dynamically injects database connection properties into Spring Boot.

By following this approach, you can test MongoDB repositories with a real database while keeping your tests fast, isolated, and disposable.