Chapter 4: 测试关系型数据库

Spring Test Framework提供了对JDBC的支持，能够让我们很方便对关系型数据库做集成测试。

同时Spring Boot提供了和Flyway的集成支持，能够方便的管理开发过程中产生的SQL文件，配合Spring已经提供的工具能够更方便地在测试之前初始化数据库以及测试之后清空数据库。

本章节为了方便起见，本章节使用了H2作为测试数据库。

注意：在真实的开发环境中，集成测试用数据库应该和最终的生产数据库保持一致，这是因为不同数据库的对于SQL不是完全相互兼容的，如果不注意这一点，很有可能出现集成测试通过，但是上了生产环境却报错的问题。

因为是集成测试，所以我们使用了maven-failsafe-plugin来跑，它和maven-surefire-plugin的差别在于，maven-failsafe-plugin只会搜索*IT.java来跑测试，而maven-surefire-plugin只会搜索*Test.java来跑测试。

如果想要在maven打包的时候跳过集成测试，只需要mvn clean install -DskipITs。

被测试类

先介绍一下被测试的类。

Foo.java：

  1. public class Foo {
  3.   private String name;
  5.   public String getName() {
  6.     return name;
  7.   }
  9.   public void setName(String name) {
  10.     this.name = name;
  11.   }
  12. }

FooRepositoryImpl.java：

  1. @Repository
  2. public class FooRepositoryImpl implements FooRepository {
  4.   private JdbcTemplate jdbcTemplate;
  6.   @Override
  7.   public void save(Foo foo) {
  8.     jdbcTemplate.update("INSERT INTO FOO(name) VALUES (?)", foo.getName());
  9.   }
  11.   @Override
  12.   public void delete(String name) {
  13.     jdbcTemplate.update("DELETE FROM FOO WHERE NAME = ?", name);
  14.   }
  16.   @Autowired
  17.   public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  18.     this.jdbcTemplate = jdbcTemplate;
  19.   }
  21. }

例子1：不使用Spring Testing提供的工具

Spring_1_IT_Configuration.java：

  1. @Configuration
  2. @ComponentScan(basePackageClasses = FooRepository.class)
  3. public class Spring_1_IT_Configuration {
  5.   @Bean(destroyMethod = "shutdown")
  6.   public DataSource dataSource() {
  8.     return new EmbeddedDatabaseBuilder()
  9.         .generateUniqueName(true)
  10.         .setType(EmbeddedDatabaseType.H2)
  11.         .setScriptEncoding("UTF-8")
  12.         .ignoreFailedDrops(true)
  13.         .addScript("classpath:me/chanjar/domain/foo-ddl.sql")
  14.         .build();
  15.   }
  17.   @Bean
  18.   public JdbcTemplate jdbcTemplate() {
  20.     return new JdbcTemplate(dataSource());
  22.   }
  23. }

在Spring_1_IT_Configuration中，我们定义了一个H2的DataSource Bean，并且构建了JdbcTemplate Bean。

注意看addScript("classpath:me/chanjar/domain/foo-ddl.sql")这句代码，我们让EmbeddedDatabase执行foo-ddl.sql脚本来建表：

  1. CREATE TABLE FOO (
  2.   name VARCHAR2(100)
  3. );

Spring_1_IT.java：

  1. @ContextConfiguration(classes = Spring_1_IT_Configuration.class)
  2. public class Spring_1_IT extends AbstractTestNGSpringContextTests {
  4.   @Autowired
  5.   private FooRepository fooRepository;
  7.   @Autowired
  8.   private JdbcTemplate jdbcTemplate;
  10.   @Test
  11.   public void testSave() {
  13.     Foo foo = new Foo();
  14.     foo.setName("Bob");
  15.     fooRepository.save(foo);
  17.     assertEquals(
  18.         jdbcTemplate.queryForObject("SELECT count(*) FROM FOO", Integer.class),
  19.         Integer.valueOf(1)
  20.     );
  22.   }
  24.   @Test(dependsOnMethods = "testSave")
  25.   public void testDelete() {
  27.     assertEquals(
  28.         jdbcTemplate.queryForObject("SELECT count(*) FROM FOO", Integer.class),
  29.         Integer.valueOf(1)
  30.     );
  32.     Foo foo = new Foo();
  33.     foo.setName("Bob");
  34.     fooRepository.save(foo);
  36.     fooRepository.delete(foo.getName());
  37.     assertEquals(
  38.         jdbcTemplate.queryForObject("SELECT count(*) FROM FOO", Integer.class),
  39.         Integer.valueOf(0)
  40.     );
  41.   }
  43. }

在这段测试代码里可以看到，我们分别测试了FooRepository的save和delete方法，并且利用JdbcTemplate来验证数据库中的结果。

例子2：使用Spring Testing提供的工具

在这个例子里，我们会使用JdbcTestUtils来辅助测试。

Spring_2_IT_Configuration.java：

  1. @Configuration
  2. @ComponentScan(basePackageClasses = FooRepository.class)
  3. public class Spring_2_IT_Configuration {
  5.   @Bean
  6.   public DataSource dataSource() {
  8.     EmbeddedDatabase db = new EmbeddedDatabaseBuilder()
  9.         .generateUniqueName(true)
  10.         .setType(EmbeddedDatabaseType.H2)
  11.         .setScriptEncoding("UTF-8")
  12.         .ignoreFailedDrops(true)
  13.         .addScript("classpath:me/chanjar/domain/foo-ddl.sql")
  14.         .build();
  15.     return db;
  16.   }
  18.   @Bean
  19.   public JdbcTemplate jdbcTemplate() {
  21.     return new JdbcTemplate(dataSource());
  23.   }
  25.   @Bean
  26.   public PlatformTransactionManager transactionManager() {
  27.     return new DataSourceTransactionManager(dataSource());
  28.   }
  30. }

这里和例子1的区别在于，我们提供了一个PlatformTransactionManager Bean，这是因为在下面的测试代码里的AbstractTransactionalTestNGSpringContextTests需要它。

Spring_2_IT.java：

  1. @ContextConfiguration(classes = Spring_2_IT_Configuration.class)
  2. public class Spring_2_IT extends AbstractTransactionalTestNGSpringContextTests {
  4.   @Autowired
  5.   private FooRepository fooRepository;
  7.   @Test
  8.   public void testSave() {
  10.     Foo foo = new Foo();
  11.     foo.setName("Bob");
  12.     fooRepository.save(foo);
  14.     assertEquals(countRowsInTable("FOO"), 1);
  15.     countRowsInTableWhere("FOO", "name = 'Bob'");
  16.   }
  18.   @Test(dependsOnMethods = "testSave")
  19.   public void testDelete() {
  21.     assertEquals(countRowsInTable("FOO"), 0);
  23.     Foo foo = new Foo();
  24.     foo.setName("Bob");
  25.     fooRepository.save(foo);
  27.     fooRepository.delete(foo.getName());
  28.     assertEquals(countRowsInTable("FOO"), 0);
  30.   }
  32. }

在这里我们使用countRowsInTable("FOO")来验证数据库结果，这个方法是AbstractTransactionalTestNGSpringContextTests对JdbcTestUtils的代理。

而且要注意的是，每个测试方法在执行完毕后，会自动rollback，所以在testDelete的第一行里，我们assertEquals(countRowsInTable("FOO"), 0)，这一点和例子1里是不同的。

更多关于Spring Testing Framework与Transaction相关的信息，可以见Spring官方文档 Transaction management。

例子3：使用Spring Boot

Boot_1_IT.java：

  1. @SpringBootTest
  2. @SpringBootApplication(scanBasePackageClasses = FooRepository.class)
  3. public class Boot_1_IT extends AbstractTransactionalTestNGSpringContextTests {
  5.   @Autowired
  6.   private FooRepository fooRepository;
  8.   @Test
  9.   public void testSave() {
  11.     Foo foo = new Foo();
  12.     foo.setName("Bob");
  13.     fooRepository.save(foo);
  15.     assertEquals(countRowsInTable("FOO"), 1);
  16.     countRowsInTableWhere("FOO", "name = 'Bob'");
  17.   }
  19.   @Test(dependsOnMethods = "testSave")
  20.   public void testDelete() {
  22.     assertEquals(countRowsInTable("FOO"), 0);
  24.     Foo foo = new Foo();
  25.     foo.setName("Bob");
  26.     fooRepository.save(foo);
  28.     fooRepository.delete(foo.getName());
  29.     assertEquals(countRowsInTable("FOO"), 0);
  31.   }
  33.   @AfterTest
  34.   public void cleanDb() {
  35.     flyway.clean();
  36.   }
  38. }

因为使用了Spring Boot来做集成测试，得益于其AutoConfiguration机制，不需要自己构建DataSource 、JdbcTemplate和PlatformTransactionManager的Bean。

并且因为我们已经将flyway-core添加到了maven依赖中，Spring Boot会利用flyway来帮助我们初始化数据库，我们需要做的仅仅是将sql文件放到classpath的db/migration目录下：

V1.0.0__foo-ddl.sql:

  2. CREATE TABLE FOO (
  3.   name VARCHAR2(100)
  4. );

而且在测试最后，我们利用flyway清空了数据库：

  1. @AfterTest
  2. public void cleanDb() {
  3.   flyway.clean();
  4. }

使用flyway有很多好处：

  1. 每个sql文件名都规定了版本号
  2. flyway按照版本号顺序执行
  3. 在开发期间，只需要将sql文件放到db/migration目录下就可以了，不需要写类似EmbeddedDatabaseBuilder.addScript()这样的代码
  4. 基于以上三点，就能够将数据库初始化SQL语句也纳入到集成测试中来，保证代码配套的SQL语句的正确性
  5. 可以帮助你清空数据库，这在你使用非内存数据库的时候非常有用，因为不管测试前还是测试后，你都需要一个干净的数据库

参考文档

本章节涉及到的Spring Testing Framework JDBC、SQL相关的工具：

和flyway相关的：