Package org.springframework.boot.test.context.runner

Class AbstractApplicationContextRunner<SELF extends AbstractApplicationContextRunner<SELF,​C,​A>,​C extends org.springframework.context.ConfigurableApplicationContext,​A extends ApplicationContextAssertProvider<C>>

  • Type Parameters:
    SELF - the "self" type for this runner
    C - the context type
    A - the application context assertion provider
    Direct Known Subclasses:
    ApplicationContextRunner, ReactiveWebApplicationContextRunner, WebApplicationContextRunner
    public abstract class AbstractApplicationContextRunner<SELF extends AbstractApplicationContextRunner<SELF,​C,​A>,​C extends org.springframework.context.ConfigurableApplicationContext,​A extends ApplicationContextAssertProvider<C>>
extends Object
    Utility design to run and an ApplicationContext and provide AssertJ style assertions. The test is best used as a field of a test class, describing the shared configuration required for the test: 
     public class MyContextTests {
     private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
             .withPropertyValues("spring.foo=bar")
             .withUserConfiguration(MyConfiguration.class);
 }

    The initialization above makes sure to register MyConfiguration for all tests and set the spring.foo property to bar unless specified otherwise.

    Based on the configuration above, a specific test can simulate what will happen when the context runs, perhaps with overridden property values: 

     @Test
 public someTest() {
     this.contextRunner.withPropertyValues("spring.foo=biz").run((context) -> {
         assertThat(context).containsSingleBean(MyBean.class);
         // other assertions
     });
 }

    The test above has changed the spring.foo property to biz and is asserting that the context contains a single MyBean bean. The run method takes a ContextConsumer that can apply assertions to the context. Upon completion, the context is automatically closed.

    If the application context fails to start the #run(ContextConsumer) method is called with a "failed" application context. Calls to the context will throw an IllegalStateException and assertions that expect a running context will fail. The getFailure() assertion can be used if further checks are required on the cause of the failure: 

     @Test
 public someTest() {
     this.context.withPropertyValues("spring.foo=fails").run((loaded) -> {
         assertThat(loaded).getFailure().hasCauseInstanceOf(BadPropertyException.class);
         // other assertions
     });
 }

    Since:
    2.0.0
    See Also:
    ApplicationContextRunner, WebApplicationContextRunner, ReactiveWebApplicationContextRunner, ApplicationContextAssert

    • Constructor Detail

      • AbstractApplicationContextRunner

        protected AbstractApplicationContextRunner​(Supplier<C> contextFactory,
                                           List<org.springframework.context.ApplicationContextInitializer<? super C>> initializers,
                                           TestPropertyValues environmentProperties,
                                           TestPropertyValues systemProperties,
                                           ClassLoader classLoader,
                                           org.springframework.context.ApplicationContext parent,
                                           List<org.springframework.boot.context.annotation.Configurations> configurations)
        Create a new AbstractApplicationContextRunner instance.
        Parameters:
        contextFactory - the factory used to create the actual context
        initializers - the initializers
        environmentProperties - the environment properties
        systemProperties - the system properties
        classLoader - the class loader
        parent - the parent
        configurations - the configuration

    • Method Detail

      • withInitializer

        public SELF withInitializer​(org.springframework.context.ApplicationContextInitializer<? super org.springframework.context.ConfigurableApplicationContext> initializer)
        Add a ApplicationContextInitializer to be called when the context is created.
        Parameters:
        initializer - the initializer to add
        Returns:
        a new instance with the updated initializers

      • withPropertyValues

        public SELF withPropertyValues​(String... pairs)
        Add the specified Environment property pairs. Key-value pairs can be specified with colon (":") or equals ("=") separators. Override matching keys that might have been specified previously.
        Parameters:
        pairs - the key-value pairs for properties that need to be added to the environment
        Returns:
        a new instance with the updated property values
        See Also:
        TestPropertyValues, withSystemProperties(String...)

      • withSystemProperties

        public SELF withSystemProperties​(String... pairs)
        Add the specified System property pairs. Key-value pairs can be specified with colon (":") or equals ("=") separators. System properties are added before the context is run and restored when the context is closed.
        Parameters:
        pairs - the key-value pairs for properties that need to be added to the system
        Returns:
        a new instance with the updated system properties
        See Also:
        TestPropertyValues, withSystemProperties(String...)

      • withClassLoader

        public SELF withClassLoader​(ClassLoader classLoader)
        Customize the ClassLoader that the ApplicationContext should use for resource loading and bean class loading.
        Parameters:
        classLoader - the classloader to use (can be null to use the default)
        Returns:
        a new instance with the updated class loader
        See Also:
        FilteredClassLoader

      • withParent

        public SELF withParent​(org.springframework.context.ApplicationContext parent)
        Configure the parent of the ApplicationContext.
        Parameters:
        parent - the parent
        Returns:
        a new instance with the updated parent

      • withUserConfiguration

        public SELF withUserConfiguration​(Class<?>... configurationClasses)
        Register the specified user configuration classes with the ApplicationContext.
        Parameters:
        configurationClasses - the user configuration classes to add
        Returns:
        a new instance with the updated configuration

      • withConfiguration

        public SELF withConfiguration​(org.springframework.boot.context.annotation.Configurations configurations)
        Register the specified configuration classes with the ApplicationContext.
        Parameters:
        configurations - the configurations to add
        Returns:
        a new instance with the updated configuration

      • with

        public SELF with​(Function<SELF,​SELF> customizer)
        Apply customization to this runner.
        Parameters:
        customizer - the customizer to call
        Returns:
        a new instance with the customizations applied

      • newInstance

        protected abstract SELF newInstance​(Supplier<C> contextFactory,
                                    List<org.springframework.context.ApplicationContextInitializer<? super C>> initializers,
                                    TestPropertyValues environmentProperties,
                                    TestPropertyValues systemProperties,
                                    ClassLoader classLoader,
                                    org.springframework.context.ApplicationContext parent,
                                    List<org.springframework.boot.context.annotation.Configurations> configurations)

      • run

        public SELF run​(ContextConsumer<? super A> consumer)
        Create and refresh a new ApplicationContext based on the current state of this loader. The context is consumed by the specified consumer and closed upon completion.
        Parameters:
        consumer - the consumer of the created ApplicationContext
        Returns:
        this instance