How SpringBoot uses EmbeddedDatabaseBuilder for database integration testing

How SpringBoot uses EmbeddedDatabaseBuilder for database integration testing

When developing SpringBoot applications, we often need to interact with the database. To ensure that our application will work properly in the production environment, we need to do database integration testing to test whether our application can properly interact with the database. In this article, we will introduce how to use SpringBoot EmbeddedDatabaseBuilderfor database integration testing.

Concept and usage of EmbeddedDatabaseBuilder

EmbeddedDatabaseBuilderIs a class provided by the Spring Framework for creating and managing embedded databases in memory. It supports a variety of database types, including H2, HSQLDB, Derby, SQLite, and more. Using EmbeddedDatabaseBuilder, we can easily create and destroy embedded databases for unit testing, integration testing, and functional testing.

EmbeddedDatabaseBuilderSeveral methods are provided for configuring and managing the embedded database. Here are some commonly used methods:

• setType: Set the embedded database type.
• setName: Set the embedded database name.
• addScript: Add SQL script file.
• setScriptEncoding: Set the SQL script file encoding.
• setDataSource: Set a custom DataSourceimplementation.

The following is a simple example to demonstrate how to EmbeddedDatabaseBuildercreate an H2 database and add a SQL script file.

EmbeddedDatabase db = new EmbeddedDatabaseBuilder()
    .setType(EmbeddedDatabaseType.H2)
    .addScript("classpath:schema.sql")
    .build();

In the above example, we EmbeddedDatabaseBuildercreated an H2 database using , and added a schema.sqlfile as an initialization script.

The concept and purpose of integration testing

In software development, integration testing is a testing method used to test the integration and interaction between different components of an application. Integration testing can help us discover and solve integration problems between components, such as communication errors, interface incompatibility, dependency problems, etc.

In a SpringBoot application, the purpose of integration testing is to ensure that various parts of the application work properly and can interact correctly with other external components (such as databases, message queues, RESTful APIs, etc.). Integration testing can help us find and fix these issues to ensure our application can run stably in production.

Database integration testing with EmbeddedDatabaseBuilder

EmbeddedDatabaseBuilderDatabase integration testing is very easy with . We just need to create an object in the test class EmbeddedDatabaseand inject it into our Repository or Service. Below is an example that demonstrates how to do database integration testing.

1. Write test cases

Suppose we have a simple Repository for querying user information. Our test case will test whether this Repository can interact with the database correctly.

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserRepositoryTest {
    
    

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testFindById() {
    
    
        User user = new User(1L, "John", "[email protected]");
        userRepository.save(user);

        User result = userRepository.findById(1L);
        assertThat(result).isNotNull();
        assertThat(result.getName()).isEqualTo("John");
        assertThat(result.getEmail()).isEqualTo("[email protected]");
    }
}

In the test case above, we used @SpringBootTestannotations to declare that this is an integration test, and it uses auto-configuration DataSource. In testFindByIdthe method, we first add a user profile to the database. Then use userRepository.findById(1L)the method to query the user information, and assert that the query result is the same as the expected value.

2. Configure the embedded database

Before executing the test cases, we need to configure the embedded database. We can create a @Configurationclass and declare a DataSourceBean for creating an embedded database. Below is an example showing how to configure the H2 database.

@Configuration
public class TestDatabaseConfig {
    
    

    @Bean
    public DataSource dataSource() {
    
    
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.H2)
                .addScript("classpath:schema.sql")
                .build();
    }
}

In the configuration above, we created a DataSourcebean and used to EmbeddedDatabaseBuilderbuild an H2 database. At the same time, we also added a schema.sqlfile as an initialization script.

3. Run the test case

Now, we are ready to run the test case. When we run a test case, SpringBoot will first load the configuration class, then create an embedded database, and inject it into our Repository. Next, our test case will use this Repository to test and verify that the test results are as expected.

Summarize

In this article, we introduced how to use SpringBoot in EmbeddedDatabaseBuilderdatabase integration testing. We first introduce EmbeddedDatabaseBuilderthe concept and usage of and then explain the concept and purpose of integration testing. Finally, we demonstrated how to use EmbeddedDatabaseBuilderintegration testing, including writing test cases, configuring the embedded database, and running test cases.

By using EmbeddedDatabaseBuilderdatabase integration testing, we can easily test whether our application can correctly interact with the database, and find and solve integration problems. This helps us ensure that our applications run stably in production.