AbstractApplicationContextRunner (Spring Boot Docs 2.2.0.RC1 API)

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 org.springframework.context.ConfigurableApplicationContext,A extends ApplicationContextAssertProvider<C>>
extends Object
```
Utility design to run 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

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class AbstractApplicationContextRunner.BeanRegistration<T>
A Bean registration to be applied when the context loaded.

Nested Classes
Modifier and Type	Class and Description
`protected class`	`AbstractApplicationContextRunner.BeanRegistration<T>` A Bean registration to be applied when the context loaded.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractApplicationContextRunner(Supplier<C> contextFactory)` Create a new `AbstractApplicationContextRunner` instance.
`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<AbstractApplicationContextRunner.BeanRegistration<?>> beanRegistrations, List<Configurations> configurations)` Create a new `AbstractApplicationContextRunner` instance.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`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<AbstractApplicationContextRunner.BeanRegistration<?>> beanRegistrations, List<Configurations> configurations)`
`SELF`	`run(ContextConsumer<? super A> consumer)` Create and refresh a new `ApplicationContext` based on the current state of this loader.
`SELF`	`with(Function<SELF,SELF> customizer)` Apply customization to this runner.
`<T> SELF`	`withBean(Class<T> type, Object... constructorArgs)` Register the specified user bean with the `ApplicationContext`.
`<T> SELF`	`withBean(Class<T> type, Supplier<T> supplier, org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)` Register the specified user bean with the `ApplicationContext`.
`<T> SELF`	`withBean(String name, Class<T> type, Object... constructorArgs)` Register the specified user bean with the `ApplicationContext`.
`<T> SELF`	`withBean(String name, Class<T> type, Supplier<T> supplier, org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)` Register the specified user bean with the `ApplicationContext`.
`SELF`	`withClassLoader(ClassLoader classLoader)` Customize the `ClassLoader` that the `ApplicationContext` should use for resource loading and bean class loading.
`SELF`	`withConfiguration(Configurations configurations)` Register the specified configuration classes with the `ApplicationContext`.
`SELF`	`withInitializer(org.springframework.context.ApplicationContextInitializer<? super C> initializer)` Add a `ApplicationContextInitializer` to be called when the context is created.
`SELF`	`withParent(org.springframework.context.ApplicationContext parent)` Configure the `parent` of the `ApplicationContext`.
`SELF`	`withPropertyValues(String... pairs)` Add the specified `Environment` property pairs.
`SELF`	`withSystemProperties(String... pairs)` Add the specified `System` property pairs.
`SELF`	`withUserConfiguration(Class<?>... configurationClasses)` Register the specified user configuration classes with the `ApplicationContext`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AbstractApplicationContextRunner
```
protected AbstractApplicationContextRunner(Supplier<C> contextFactory)
```
    Create a new AbstractApplicationContextRunner instance.
    
    Parameters:
    
    contextFactory - the factory used to create the actual context
  - 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<AbstractApplicationContextRunner.BeanRegistration<?>> beanRegistrations,
                                           List<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
    
    beanRegistrations - the bean registrations
    
    configurations - the configuration
- Method Detail
  - withInitializer
```
public SELF withInitializer(org.springframework.context.ApplicationContextInitializer<? super C> 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
  - withBean
```
public <T> SELF withBean(Class<T> type,
                         Object... constructorArgs)
```
    Register the specified user bean with the ApplicationContext. The bean name is generated from the configured BeanNameGenerator on the underlying context.
    Such beans are registered after regular user configurations in the order of registration.
    
    Type Parameters:
    
    T - the type of the bean
    
    Parameters:
    
    type - the type of the bean
    
    constructorArgs - custom argument values to be fed into Spring's constructor resolution algorithm, resolving either all arguments or just specific ones, with the rest to be resolved through regular autowiring (may be null or empty)
    
    Returns:
    
    a new instance with the updated bean
  - withBean
```
public <T> SELF withBean(String name,
                         Class<T> type,
                         Object... constructorArgs)
```
    Register the specified user bean with the ApplicationContext.
    Such beans are registered after regular user configurations in the order of registration.
    
    Type Parameters:
    
    T - the type of the bean
    
    Parameters:
    
    name - the bean name or null to use a generated name
    
    type - the type of the bean
    
    constructorArgs - custom argument values to be fed into Spring's constructor resolution algorithm, resolving either all arguments or just specific ones, with the rest to be resolved through regular autowiring (may be null or empty)
    
    Returns:
    
    a new instance with the updated bean
  - withBean
```
public <T> SELF withBean(Class<T> type,
                         Supplier<T> supplier,
                         org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)
```
    Register the specified user bean with the ApplicationContext. The bean name is generated from the configured BeanNameGenerator on the underlying context.
    Such beans are registered after regular user configurations in the order of registration.
    
    Type Parameters:
    
    T - the type of the bean
    
    Parameters:
    
    type - the type of the bean
    
    supplier - a supplier for the bean
    
    customizers - one or more callbacks for customizing the factory's BeanDefinition, e.g. setting a lazy-init or primary flag
    
    Returns:
    
    a new instance with the updated bean
  - withBean
```
public <T> SELF withBean(String name,
                         Class<T> type,
                         Supplier<T> supplier,
                         org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)
```
    Register the specified user bean with the ApplicationContext. The bean name is generated from the configured BeanNameGenerator on the underlying context.
    Such beans are registered after regular user configurations in the order of registration.
    
    Type Parameters:
    
    T - the type of the bean
    
    Parameters:
    
    name - the bean name or null to use a generated name
    
    type - the type of the bean
    
    supplier - a supplier for the bean
    
    customizers - one or more callbacks for customizing the factory's BeanDefinition, e.g. setting a lazy-init or primary flag
    
    Returns:
    
    a new instance with the updated bean
  - 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
  - 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<AbstractApplicationContextRunner.BeanRegistration<?>> beanRegistrations,
                                    List<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

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

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractApplicationContextRunner

AbstractApplicationContextRunner

Method Detail

withInitializer

withPropertyValues

withSystemProperties

withClassLoader

withParent

withBean

withBean

withBean

withBean

withUserConfiguration

withConfiguration

with

newInstance

run