• Chapter 7: 测试@Configuration
    • 例子1：测试@Configuration
    • 例子2：测试@Conditional
    • 例子3：测试@ConditionalOnProperty
    • 例子4：测试Configuration Properties
    • 参考文档

    Chapter 7: 测试@Configuration

    在Spring引入Java Config机制之后，我们会越来越多的使用@Configuration来注册Bean，并且Spring Boot更广泛地使用了这一机制，其提供的大量Auto Configuration大大简化了配置工作。那么问题来了，如何确保@Configuration和Auto Configuration按照预期运行呢，是否正确地注册了Bean呢？本章举例测试@Configuration和Auto Configuration的方法（因为Auto Configuration也是@Configuration，所以测试方法是一样的）。

    例子1：测试@Configuration

    我们先写一个简单的@Configuration：

    1. @Configuration
    2. public class FooConfiguration {
    4.   @Bean
    5.   public Foo foo() {
    6.     return new Foo();
    7.   }
    9. }

    然后看FooConfiguration是否能够正确地注册Bean：

    1. public class FooConfigurationTest {
    3.   private AnnotationConfigApplicationContext context;
    5.   @BeforeMethod
    6.   public void init() {
    7.     context = new AnnotationConfigApplicationContext();
    8.   }
    10.   @AfterMethod(alwaysRun = true)
    11.   public void reset() {
    12.     context.close();
    13.   }
    15.   @Test
    16.   public void testFooCreation() {
    17.     context.register(FooConfiguration.class);
    18.     context.refresh();
    19.     assertNotNull(context.getBean(Foo.class));
    20.   }
    22. }

    注意上面代码中关于Context的代码：

    1. 首先，我们构造一个Context
    2. 然后，注册FooConfiguration
    3. 然后，refresh Context
    4. 最后，在测试方法结尾close Context

    如果你看Spring Boot中关于@Configuration测试的源代码会发现和上面的代码有点不一样：

    1. public class DataSourceAutoConfigurationTests {
    3.     private final AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    5.     @Before
    6.     public void init() {
    7.         EmbeddedDatabaseConnection.override = null;
    8.         EnvironmentTestUtils.addEnvironment(this.context,
    9.                 "spring.datasource.initialize:false",
    10.                 "spring.datasource.url:jdbc:hsqldb:mem:testdb-" + new Random().nextInt());
    11.     }
    13.     @After
    14.     public void restore() {
    15.         EmbeddedDatabaseConnection.override = null;
    16.         this.context.close();
    17.     }

    这是因为Spring和Spring Boot都是用JUnit做测试的，而JUnit的特性是每次执行测试方法前，都会new一个测试类实例，而TestNG是在共享同一个测试类实例的。

    例子2：测试@Conditional

    Spring Framework提供了一种可以条件控制@Configuration的机制，即只在满足某条件的情况下才会导入@Configuration，这就是@Conditional。

    下面我们来对@Conditional做一些测试，首先我们自定义一个Condition FooConfiguration：

    1. @Configuration
    2. public class FooConfiguration {
    4.   @Bean
    5.   @Conditional(FooCondition.class)
    6.   public Foo foo() {
    7.     return new Foo();
    8.   }
    10.   public static class FooCondition implements Condition {
    12.     @Override
    13.     public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
    14.       if (context.getEnvironment() != null) {
    15.         Boolean property = context.getEnvironment().getProperty("foo.create", Boolean.class);
    16.         return Boolean.TRUE.equals(property);
    17.       }
    18.       return false;
    19.     }
    21.   }
    22. }

    该Condition判断Environment中是否有foo.create=true。

    如果我们要测试这个Condition，那么就必须往Environment里添加相关property才可以，在这里我们测试了三种情况：

    1. 没有配置foo.create=true
    2. 配置foo.create=true
    3. 配置foo.create=false

    FooConfigurationTest：

    1. public class FooConfigurationTest {
    3.   private AnnotationConfigApplicationContext context;
    5.   @BeforeMethod
    6.   public void init() {
    7.     context = new AnnotationConfigApplicationContext();
    8.   }
    10.   @AfterMethod(alwaysRun = true)
    11.   public void reset() {
    12.     context.close();
    13.   }
    15.   @Test(expectedExceptions = NoSuchBeanDefinitionException.class)
    16.   public void testFooCreatePropertyNull() {
    17.     context.register(FooConfiguration.class);
    18.     context.refresh();
    19.     context.getBean(Foo.class);
    20.   }
    22.   @Test
    23.   public void testFooCreatePropertyTrue() {
    24.     context.getEnvironment().getPropertySources().addLast(
    25.         new MapPropertySource("test", Collections.singletonMap("foo.create", "true"))
    26.     );
    27.     context.register(FooConfiguration.class);
    28.     context.refresh();
    29.     assertNotNull(context.getBean(Foo.class));
    30.   }
    32.   @Test(expectedExceptions = NoSuchBeanDefinitionException.class)
    33.   public void testFooCreatePropertyFalse() {
    34.     context.getEnvironment().getPropertySources().addLast(
    35.         new MapPropertySource("test", Collections.singletonMap("foo.create", "false"))
    36.     );
    37.     context.register(FooConfiguration.class);
    38.     context.refresh();
    39.     assertNotNull(context.getBean(Foo.class));
    40.   }
    42. }

    注意我们用以下方法来给Environment添加property：

    1. context.getEnvironment().getPropertySources().addLast(
    2.   new MapPropertySource("test", Collections.singletonMap("foo.create", "true"))
    3. );

    所以针对@Conditional和其对应的Condition的测试的根本就是给它不一样的条件，判断其行为是否正确，在这个例子里我们的Condition比较简单，只是判断是否存在某个property，如果复杂Condition的话，测试思路也是一样的。

    例子3：测试@ConditionalOnProperty

    Spring framework只提供了@Conditional，Spring boot对这个机制做了扩展，提供了更为丰富的@ConditionalOn*，这里我们以@ConditionalOnProperty举例说明。

    先看FooConfiguration：

    1. @Configuration
    2. public class FooConfiguration {
    4.   @Bean
    5.   @ConditionalOnProperty(prefix = "foo", name = "create", havingValue = "true")
    6.   public Foo foo() {
    7.     return new Foo();
    8.   }
    10. }

    FooConfigurationTest：

    1. public class FooConfigurationTest {
    3.   private AnnotationConfigApplicationContext context;
    5.   @BeforeMethod
    6.   public void init() {
    7.     context = new AnnotationConfigApplicationContext();
    8.   }
    10.   @AfterMethod(alwaysRun = true)
    11.   public void reset() {
    12.     context.close();
    13.   }
    15.   @Test(expectedExceptions = NoSuchBeanDefinitionException.class)
    16.   public void testFooCreatePropertyNull() {
    17.     context.register(FooConfiguration.class);
    18.     context.refresh();
    19.     context.getBean(Foo.class);
    20.   }
    22.   @Test
    23.   public void testFooCreatePropertyTrue() {
    24.     EnvironmentTestUtils.addEnvironment(context, "foo.create=true");
    25.     context.register(FooConfiguration.class);
    26.     context.refresh();
    27.     assertNotNull(context.getBean(Foo.class));
    28.   }
    30.   @Test(expectedExceptions = NoSuchBeanDefinitionException.class)
    31.   public void testFooCreatePropertyFalse() {
    32.     EnvironmentTestUtils.addEnvironment(context, "foo.create=false");
    33.     context.register(FooConfiguration.class);
    34.     context.refresh();
    35.     assertNotNull(context.getBean(Foo.class));
    36.   }
    38. }

    这段测试代码和例子2的逻辑差不多，只不过例子2里使用了我们自己写的Condition，这里使用了Spring Boot提供的@ConditionalOnProperty。

    并且利用了Spring Boot提供的EnvironmentTestUtils简化了给Environment添加property的工作：

    1. EnvironmentTestUtils.addEnvironment(context, "foo.create=false");

    例子4：测试Configuration Properties

    Spring Boot还提供了类型安全的Configuration Properties，下面举例如何对其进行测试。

    BarConfiguration：

    1. @Configuration
    2. @EnableConfigurationProperties(BarConfiguration.BarProperties.class)
    3. public class BarConfiguration {
    5.   @Autowired
    6.   private BarProperties barProperties;
    8.   @Bean
    9.   public Bar bar() {
    10.     return new Bar(barProperties.getName());
    11.   }
    13.   @ConfigurationProperties("bar")
    14.   public static class BarProperties {
    16.     private String name;
    18.     public String getName() {
    19.       return name;
    20.     }
    22.     public void setName(String name) {
    23.       this.name = name;
    24.     }
    25.   }
    27. }

    BarConfigurationTest：

    1. public class BarConfigurationTest {
    3.   private AnnotationConfigApplicationContext context;
    5.   @BeforeMethod
    6.   public void init() {
    7.     context = new AnnotationConfigApplicationContext();
    8.   }
    10.   @AfterMethod(alwaysRun = true)
    11.   public void reset() {
    12.     context.close();
    13.   }
    15.   @Test
    16.   public void testBarCreation() {
    17.     EnvironmentTestUtils.addEnvironment(context, "bar.name=test");
    18.     context.register(BarConfiguration.class, PropertyPlaceholderAutoConfiguration.class);
    19.     context.refresh();
    20.     assertEquals(context.getBean(Bar.class).getName(), "test");
    21.   }
    23. }

    注意到因为我们使用了Configuration Properties机制，需要注册PropertyPlaceholderAutoConfiguration，否则在BarConfiguration里无法注入BarProperties。

    参考文档

    • Conditionally include @Configuration classes or @Bean methods
    • Condition annotations
    • Type-safe Configuration Properties
    • Spring Framework Testing
    • Spring Boot Testing