org.springframework.boot.test.context.runner

Class AbstractApplicationContextRunner<SELF extends AbstractApplicationContextRunner<SELF,C,A>,C extends ConfigurableApplicationContext,A extends ApplicationContextAssertProvider<C>>

  • java.lang.Object
    • org.springframework.boot.test.context.runner.AbstractApplicationContextRunner<SELF,C,A>
  • 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 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
    Author:
    Stephane Nicoll, Andy Wilkinson, Phillip Webb
    See Also:
    ApplicationContextRunner, WebApplicationContextRunner, ReactiveWebApplicationContextRunner, ApplicationContextAssert
    • Method Detail

      • 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
      • 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(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
      • 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