or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

assertj-integration.md context-runners.md index.md integration-testing.md json-testing.md output-capture.md test-configuration.md test-properties.md web-test-utilities.md

tile.json

Context Runners for Isolated Testing

Lightweight application context testing utilities for testing auto-configurations and components in isolation without full application startup.

Package

org.springframework.boot.test.context.runner

Prerequisites

Spring Framework Test support
Configuration classes to test
No @SpringBootApplication required

Core Imports

import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner;
import org.springframework.boot.test.context.runner.ContextConsumer;
import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
import org.springframework.beans.factory.config.BeanDefinitionCustomizer;
import static org.assertj.core.api.Assertions.assertThat;

ContextConsumer

Full Package: org.springframework.boot.test.context.runner.ContextConsumer

Functional interface for processing an ApplicationContext with the ability to throw checked exceptions. Used as the callback parameter in run() and prepare() methods of context runners.

/**
 * Callback interface used to process an ApplicationContext with the ability to throw a checked exception
 * @param <C> the application context type
 * @since 2.0.0
 */
@FunctionalInterface
public interface ContextConsumer<C extends ApplicationContext> {

    /**
     * Performs this operation on the supplied context
     * @param context the application context to consume
     * @throws Throwable any exception that might occur in assertions
     */
    void accept(C context) throws Throwable;

    /**
     * Returns a composed ContextConsumer that performs, in sequence, this operation followed by the after operation
     * @param after the operation to perform after this operation
     * @return a composed ContextConsumer that performs in sequence this operation followed by the after operation
     * @since 2.6.0
     */
    default ContextConsumer<C> andThen(ContextConsumer<? super C> after);
}

Usage Examples:

// Simple usage
contextRunner.run(context -> {
    assertThat(context).hasSingleBean(MyService.class);
});

// Chained usage with andThen
ContextConsumer<AssertableApplicationContext> checkBeans = context ->
    assertThat(context).hasSingleBean(DataSource.class);

ContextConsumer<AssertableApplicationContext> checkProperties = context ->
    assertThat(context.getEnvironment().getProperty("app.name")).isEqualTo("test");

contextRunner.run(checkBeans.andThen(checkProperties));

ApplicationContextRunner

Full Package: org.springframework.boot.test.context.runner.ApplicationContextRunner

Non-web context runner for standard application context testing.

public final class ApplicationContextRunner
    extends AbstractApplicationContextRunner<
        ApplicationContextRunner,
        ConfigurableApplicationContext,
        AssertableApplicationContext> {

    public ApplicationContextRunner(); // Default constructor
    public ApplicationContextRunner(Supplier<ConfigurableApplicationContext> contextFactory);
    public ApplicationContextRunner(Supplier<ConfigurableApplicationContext> contextFactory, Class<?>... additionalContextInterfaces); // @since 3.4.0
}

Common Methods

// Configuration
withUserConfiguration(Class<?>... configurationClasses)
withConfiguration(Configurations configurations)
withPropertyValues(String... pairs)                    // "key=value"
withSystemProperties(String... pairs)                  // Temporary
withBean(Class<T> type, Object... constructorArgs)
withBean(String name, Class<T> type, Supplier<T> supplier)
withInitializer(ApplicationContextInitializer<...> initializer)
withParent(ApplicationContext parent)
withAllowBeanDefinitionOverriding(boolean allow)

// Execution
run(ContextConsumer<AssertableApplicationContext> consumer)     // Runs and auto-closes
prepare(ContextConsumer<AssertableApplicationContext> consumer) // Prepares without refresh

Common Patterns

Pattern: Basic Auto-Configuration Test

import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;

@AutoConfiguration
@ConditionalOnProperty("feature.enabled")
class MyAutoConfiguration {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

class MyAutoConfigurationTest {

    private final ApplicationContextRunner contextRunner = 
        new ApplicationContextRunner()
            .withUserConfiguration(MyAutoConfiguration.class);

    @Test
    void whenPropertySet_beanCreated() {
        contextRunner
            .withPropertyValues("feature.enabled=true")
            .run(context -> {
                assertThat(context).hasSingleBean(MyService.class);
                assertThat(context).hasBean("myService");
            });
    }

    @Test
    void whenPropertyNotSet_beanNotCreated() {
        contextRunner
            .run(context -> {
                assertThat(context).doesNotHaveBean(MyService.class);
            });
    }
}

Pattern: Testing Context Startup Failure

@Test
void whenInvalidConfig_contextFails() {
    contextRunner
        .withUserConfiguration(InvalidConfig.class)
        .run(context -> {
            assertThat(context).hasFailed();
            assertThat(context).getFailure()
                .isInstanceOf(BeanCreationException.class)
                .hasMessageContaining("expected error");
        });
}

Pattern: Bean Registration

@Test
void testWithRegisteredBean() {
    contextRunner
        .withBean("customService", MyService.class, () -> new MyService("test"))
        .run(context -> {
            assertThat(context).hasBean("customService");
            MyService service = context.getBean("customService", MyService.class);
            assertThat(service.getName()).isEqualTo("test");
        });
}

Pattern: Filtered ClassLoader

import org.springframework.boot.test.context.FilteredClassLoader;

@Test
void whenClassMissing_fallbackUsed() {
    contextRunner
        .withClassLoader(new FilteredClassLoader(SomeClass.class))
        .withUserConfiguration(MyAutoConfiguration.class)
        .run(context -> {
            assertThat(context).hasBean("fallbackBean");
        });
}

WebApplicationContextRunner

Full Package: org.springframework.boot.test.context.runner.WebApplicationContextRunner

Servlet-based web context runner for testing web components with MockServletContext.

public final class WebApplicationContextRunner
    extends AbstractApplicationContextRunner<
        WebApplicationContextRunner,
        ConfigurableWebApplicationContext,
        AssertableWebApplicationContext> {

    /**
     * Create a new WebApplicationContextRunner with MockServletContext
     * Uses AnnotationConfigServletWebApplicationContext with MockServletContext
     * @since 2.0.0
     */
    public WebApplicationContextRunner();

    /**
     * Create with a custom context factory
     * @param contextFactory supplier that returns new context instance
     * @since 2.0.0
     */
    public WebApplicationContextRunner(Supplier<ConfigurableWebApplicationContext> contextFactory);

    /**
     * Create with custom factory and additional interfaces
     * @param contextFactory supplier that returns new context instance
     * @param additionalContextInterfaces additional interfaces for context proxy
     * @since 3.4.0
     */
    public WebApplicationContextRunner(Supplier<ConfigurableWebApplicationContext> contextFactory, Class<?>... additionalContextInterfaces);

    /**
     * Decorate a context factory to set MockServletContext on each new context
     * Useful for custom WebApplicationContext implementations
     * @param contextFactory the context factory to decorate
     * @return decorated supplier that sets MockServletContext
     * @since 2.0.0
     */
    public static Supplier<ConfigurableWebApplicationContext> withMockServletContext(
        Supplier<ConfigurableWebApplicationContext> contextFactory);
}

Usage Examples:

// Default usage - automatically includes MockServletContext
new WebApplicationContextRunner()
    .withUserConfiguration(WebMvcConfig.class)
    .run(context -> {
        assertThat(context).hasSingleBean(DispatcherServlet.class);
        assertThat(context.getServletContext()).isInstanceOf(MockServletContext.class);
    });

// Custom context factory with MockServletContext
new WebApplicationContextRunner(
    WebApplicationContextRunner.withMockServletContext(
        () -> new CustomWebApplicationContext()
    )
)
    .run(context -> {
        assertThat(context).isInstanceOf(CustomWebApplicationContext.class);
        assertThat(context.getServletContext()).isNotNull();
    });

ReactiveWebApplicationContextRunner

Full Package: org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner

Reactive web context runner.

public final class ReactiveWebApplicationContextRunner
    extends AbstractApplicationContextRunner<
        ReactiveWebApplicationContextRunner,
        ConfigurableReactiveWebApplicationContext,
        AssertableReactiveWebApplicationContext> {

    public ReactiveWebApplicationContextRunner(); // Available since 2.0.0 (when class was introduced)
    public ReactiveWebApplicationContextRunner(Supplier<ConfigurableReactiveWebApplicationContext> contextFactory); // @since 3.4.0
    public ReactiveWebApplicationContextRunner(Supplier<ConfigurableReactiveWebApplicationContext> contextFactory, Class<?>... additionalContextInterfaces); // @since 3.4.0
}

FilteredClassLoader

Full Package: org.springframework.boot.test.context.FilteredClassLoader

Test classloader that filters specific classes/packages.

public class FilteredClassLoader extends URLClassLoader implements SmartClassLoader {
    public FilteredClassLoader(Class<?>... hiddenClasses);
    public FilteredClassLoader(ClassLoader parent, Class<?>... hiddenClasses);
    public FilteredClassLoader(String... hiddenPackages);
    public FilteredClassLoader(ClassPathResource... hiddenResources);
    public FilteredClassLoader(Predicate<String>... filters);

    // SmartClassLoader support
    public Class<?> publicDefineClass(String name, byte[] b, ProtectionDomain protectionDomain);

    // Nested Filter Classes
    public static final class ClassFilter implements Predicate<String> {
        public static ClassFilter of(Class<?>... hiddenClasses);
    }

    public static final class PackageFilter implements Predicate<String> {
        public static PackageFilter of(String... hiddenPackages);
    }

    public static final class ClassPathResourceFilter implements Predicate<String> {
        public static ClassPathResourceFilter of(ClassPathResource... hiddenResources);
    }
}

Complete API Reference

AbstractApplicationContextRunner Methods

Full Package: org.springframework.boot.test.context.runner.AbstractApplicationContextRunner<SELF, C, A>

// Configuration Methods
public SELF withUserConfiguration(Class<?>... configurationClasses);
public SELF withConfiguration(Configurations configurations);

// Property Management
public SELF withPropertyValues(String... pairs);          // "key=value" format
public SELF withSystemProperties(String... pairs);        // Temporary, removed after test

// Bean Registration
public <T> SELF withBean(Class<T> type, Object... constructorArgs);
public <T> SELF withBean(@Nullable String name, Class<T> type, Object... constructorArgs);
public <T> SELF withBean(Class<T> type, Supplier<T> supplier, BeanDefinitionCustomizer... customizers);
public <T> SELF withBean(@Nullable String name, Class<T> type, Supplier<T> supplier, BeanDefinitionCustomizer... customizers);

// Customization
public SELF with(Function<SELF, SELF> customizer);
public SELF withInitializer(ApplicationContextInitializer<? super C> initializer);

// Context Configuration
public SELF withClassLoader(@Nullable ClassLoader classLoader);
public SELF withParent(ApplicationContext parent);
public SELF withAllowBeanDefinitionOverriding(boolean allowBeanDefinitionOverriding);
public SELF withAllowCircularReferences(boolean allowCircularReferences);

// Execution
public SELF run(ContextConsumer<? super A> consumer);
public SELF prepare(ContextConsumer<? super A> consumer); // Since 3.0.0

FilteredClassLoader Complete API

Full Package: org.springframework.boot.test.context.FilteredClassLoader Since: 2.0.0

public class FilteredClassLoader extends URLClassLoader implements SmartClassLoader {
    // Constructors
    public FilteredClassLoader(Class<?>... hiddenClasses);
    public FilteredClassLoader(ClassLoader parent, Class<?>... hiddenClasses);
    public FilteredClassLoader(String... hiddenPackages);
    public FilteredClassLoader(ClassPathResource... hiddenResources);
    public FilteredClassLoader(Predicate<String>... filters);

    // SmartClassLoader support
    public Class<?> publicDefineClass(String name, byte[] b, @Nullable ProtectionDomain protectionDomain);

    // Nested Filter Classes
    public static final class ClassFilter implements Predicate<String> {
        public static ClassFilter of(Class<?>... hiddenClasses);
    }

    public static final class PackageFilter implements Predicate<String> {
        public static PackageFilter of(String... hiddenPackages);
    }

    public static final class ClassPathResourceFilter implements Predicate<String> {
        public static ClassPathResourceFilter of(ClassPathResource... hiddenResources);
    }
}

WebApplicationContextRunner Specific

Full Package: org.springframework.boot.test.context.runner.WebApplicationContextRunner

public final class WebApplicationContextRunner
    extends AbstractApplicationContextRunner<...> {

    public WebApplicationContextRunner();
    public WebApplicationContextRunner(Supplier<ConfigurableWebApplicationContext> contextFactory);

    // Utility for creating context with MockServletContext
    @Contract("!null -> !null")
    public static @Nullable Supplier<ConfigurableWebApplicationContext> withMockServletContext(
        @Nullable Supplier<ConfigurableWebApplicationContext> contextFactory
    );
}

Additional Usage Patterns

Pattern: Testing with Custom Context Factory

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

@Test
void testWithCustomContextFactory() {
    new ApplicationContextRunner(() -> {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.setDisplayName("CustomTestContext");
        return context;
    })
    .withUserConfiguration(MyConfig.class)
    .run(context -> {
        assertThat(context.getDisplayName()).contains("CustomTestContext");
    });
}

Pattern: Testing with Parent Context

@Test
void testWithParentContext() {
    ApplicationContext parent = new AnnotationConfigApplicationContext(ParentConfig.class);

    new ApplicationContextRunner()
        .withParent(parent)
        .withUserConfiguration(ChildConfig.class)
        .run(context -> {
            // Child can access parent beans
            assertThat(context.getBean(ParentBean.class)).isNotNull();
            assertThat(context.getBean(ChildBean.class)).isNotNull();
        });
}

Pattern: Testing Context Preparation (Since 3.0.0)

@Test
void testPrepareWithoutRefresh() {
    new ApplicationContextRunner()
        .withUserConfiguration(MyConfig.class)
        .prepare(context -> {
            // Context is prepared but not refreshed
            // Useful for testing initialization logic
            assertThat(context.getBeanFactory()).isNotNull();
            assertThat(context.isActive()).isFalse();
        });
}

Pattern: Testing with Multiple Filtered Classes

@Test
void testWithMultipleFilteredClasses() {
    ClassLoader filteredLoader = new FilteredClassLoader(
        HikariDataSource.class,
        PostgreSQLDriver.class
    );

    contextRunner
        .withClassLoader(filteredLoader)
        .withUserConfiguration(DataSourceAutoConfiguration.class)
        .run(context -> {
            // Should use H2 fallback when PostgreSQL not available
            assertThat(context).hasSingleBean(DataSource.class);
            assertThat(context.getBean(DataSource.class))
                .isNotInstanceOf(HikariDataSource.class);
        });
}

Pattern: Testing with Filtered Packages

@Test
void testWithFilteredPackages() {
    ClassLoader filteredLoader = new FilteredClassLoader(
        "com.zaxxer.hikari",
        "org.postgresql"
    );

    contextRunner
        .withClassLoader(filteredLoader)
        .withUserConfiguration(MyAutoConfiguration.class)
        .run(context -> {
            assertThat(context).doesNotHaveBean("hikariDataSource");
        });
}

Pattern: Testing with Filtered Resources

import org.springframework.core.io.ClassPathResource;

@Test
void testWithFilteredResources() {
    ClassLoader filteredLoader = new FilteredClassLoader(
        new ClassPathResource("application.properties"),
        new ClassPathResource("config/application.yml")
    );

    contextRunner
        .withClassLoader(filteredLoader)
        .withUserConfiguration(MyConfig.class)
        .run(context -> {
            // Configuration should use defaults when files not found
            assertThat(context.getEnvironment().getProperty("custom.property"))
                .isNull();
        });
}

Pattern: Testing Bean Overriding

@Configuration
class OriginalConfig {
    @Bean
    public MyService myService() {
        return new OriginalServiceImpl();
    }
}

@Configuration
class OverrideConfig {
    @Bean
    public MyService myService() {
        return new OverriddenServiceImpl();
    }
}

@Test
void testBeanOverriding() {
    new ApplicationContextRunner()
        .withAllowBeanDefinitionOverriding(true)
        .withUserConfiguration(OriginalConfig.class, OverrideConfig.class)
        .run(context -> {
            assertThat(context.getBean(MyService.class))
                .isInstanceOf(OverriddenServiceImpl.class);
        });
}

Pattern: Testing with System Properties

@Test
void testWithSystemProperties() {
    new ApplicationContextRunner()
        .withSystemProperties(
            "java.io.tmpdir=/custom/tmp",
            "user.timezone=UTC"
        )
        .withUserConfiguration(SystemPropertiesConfig.class)
        .run(context -> {
            // System properties are set during test and restored after
            assertThat(System.getProperty("java.io.tmpdir"))
                .isEqualTo("/custom/tmp");

            MyService service = context.getBean(MyService.class);
            assertThat(service.getTmpDir()).isEqualTo("/custom/tmp");
        });
    // System properties restored here
}

Pattern: Testing Circular References

@Test
void testCircularReferences() {
    new ApplicationContextRunner()
        .withAllowCircularReferences(true)
        .withUserConfiguration(CircularConfig.class)
        .run(context -> {
            // Context loads successfully despite circular references
            assertThat(context).hasSingleBean(ServiceA.class);
            assertThat(context).hasSingleBean(ServiceB.class);
        });
}

Pattern: Testing with Bean Definition Customizers

@Test
void testWithBeanCustomizers() {
    new ApplicationContextRunner()
        .withBean("myService", MyService.class,
            () -> new MyService("test"),
            bd -> {
                bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
                bd.setLazyInit(true);
            })
        .run(context -> {
            BeanDefinition bd = context.getBeanFactory()
                .getBeanDefinition("myService");

            assertThat(bd.getScope()).isEqualTo(BeanDefinition.SCOPE_PROTOTYPE);
            assertThat(bd.isLazyInit()).isTrue();
        });
}

Pattern: Testing with Initializers

@Test
void testWithInitializers() {
    new ApplicationContextRunner()
        .withInitializer(context -> {
            context.getBeanFactory().registerSingleton("earlyBean", new EarlyBean());
        })
        .withUserConfiguration(MyConfig.class)
        .run(context -> {
            assertThat(context).hasBean("earlyBean");
        });
}

Pattern: Testing with Customizer Function

private ApplicationContextRunner baseRunner() {
    return new ApplicationContextRunner()
        .withPropertyValues("app.name=test")
        .withUserConfiguration(BaseConfig.class);
}

@Test
void testWithCustomizer() {
    baseRunner()
        .with(runner -> runner
            .withPropertyValues("app.feature=enabled")
            .withBean(FeatureService.class))
        .run(context -> {
            assertThat(context).hasBean("featureService");
        });
}

Pattern: Testing Reactive Web Context

@Test
void testReactiveWebContext() {
    new ReactiveWebApplicationContextRunner()
        .withUserConfiguration(ReactiveWebConfig.class)
        .run(context -> {
            assertThat(context).hasSingleBean(WebFilter.class);
            assertThat(context).hasSingleBean(RouterFunction.class);
        });
}

Pattern: Testing Web Context with Servlet

@Test
void testWebContextWithServlet() {
    new WebApplicationContextRunner()
        .withUserConfiguration(WebConfig.class)
        .run(context -> {
            assertThat(context).hasSingleBean(ServletRegistrationBean.class);
            assertThat(context.getServletContext()).isNotNull();
        });
}

Pattern: Reusable Runner Base Configuration

abstract class AutoConfigurationTestBase {

    protected final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
        .withConfiguration(AutoConfigurations.of(
            MyAutoConfiguration.class,
            DependencyAutoConfiguration.class
        ))
        .withPropertyValues(
            "logging.level.test=DEBUG",
            "spring.main.banner-mode=off"
        );

    @Test
    void testCommonBehavior() {
        contextRunner.run(context -> {
            assertThat(context).hasBean("commonBean");
        });
    }
}

class SpecificAutoConfigTest extends AutoConfigurationTestBase {

    @Test
    void testSpecificFeature() {
        contextRunner
            .withPropertyValues("feature.enabled=true")
            .run(context -> {
                assertThat(context).hasBean("featureBean");
            });
    }
}

Pattern: Testing Auto-Configuration with Conditions

@AutoConfiguration
@ConditionalOnClass(DataSource.class)
@ConditionalOnProperty(name = "datasource.enabled", havingValue = "true")
class DataSourceAutoConfiguration {
    @Bean
    public DataSource dataSource() {
        return new EmbeddedDataSource();
    }
}

class DataSourceAutoConfigurationTest {

    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
        .withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class));

    @Test
    void whenClassPresent_andPropertySet_beanCreated() {
        contextRunner
            .withPropertyValues("datasource.enabled=true")
            .run(context -> {
                assertThat(context).hasSingleBean(DataSource.class);
            });
    }

    @Test
    void whenPropertyNotSet_beanNotCreated() {
        contextRunner
            .run(context -> {
                assertThat(context).doesNotHaveBean(DataSource.class);
            });
    }

    @Test
    void whenClassAbsent_beanNotCreated() {
        contextRunner
            .withClassLoader(new FilteredClassLoader(DataSource.class))
            .withPropertyValues("datasource.enabled=true")
            .run(context -> {
                assertThat(context).doesNotHaveBean(DataSource.class);
            });
    }
}

Pattern: Testing Context Startup Failures

@Test
void testFailureScenarios() {
    contextRunner
        .withUserConfiguration(InvalidConfig.class)
        .run(context -> {
            // Assert context failed to start
            assertThat(context).hasFailed();

            // Assert on failure type
            assertThat(context).getFailure()
                .isInstanceOf(BeanCreationException.class)
                .hasMessageContaining("Could not create bean");

            // Assert on root cause
            assertThat(context).getFailure()
                .getRootCause()
                .isInstanceOf(IllegalStateException.class)
                .hasMessage("Invalid configuration");
        });
}

Troubleshooting

Common Issues

Issue: Beans not found in context

Cause: Missing configuration in withUserConfiguration()
Solution: Include all required @Configuration classes explicitly

Example:

contextRunner
    .withUserConfiguration(MyConfig.class, DependencyConfig.class)
    .run(context -> { /* test */ });

Issue: Properties not applied

Cause: Using wrong property format (colon instead of equals)
Solution: Use "key=value" format, not "key:value"
Example: withPropertyValues("server.port=8080") not "server.port: 8080"

Issue: Context doesn't fail as expected

Cause: Error absorbed by framework or wrong exception type
Solution: Check .getFailure() for root cause and exception chain

Debug:

.run(context -> {
    assertThat(context).hasFailed();
    context.getFailure().printStackTrace(); // Debug output
});

Issue: Filtered class not working

Cause: Class loaded before filter applied
Solution: Ensure FilteredClassLoader set before context creation
Verification: Check classloader is FilteredClassLoader type

Issue: System properties persist after test

Cause: Not using withSystemProperties() method
Solution: Use runner's withSystemProperties() for automatic cleanup

Issue: Bean definition overriding not allowed

Cause: Default behavior disallows overriding
Solution: Use withAllowBeanDefinitionOverriding(true)

Issue: Circular dependency error

Cause: Circular references not allowed by default
Solution: Use withAllowCircularReferences(true) or fix design

Issue: Wrong context type loaded

Cause: Using wrong runner (ApplicationContextRunner vs WebApplicationContextRunner)
Solution: Use WebApplicationContextRunner for web contexts

Issue: MockServletContext not available in web runner

Cause: Custom context factory doesn't set servlet context
Solution: Use WebApplicationContextRunner.withMockServletContext()

Issue: Parent context beans not accessible

Cause: Parent not set correctly
Solution: Verify parent context is active before setting

Error Messages and Solutions

Error: "BeanDefinitionOverrideException"

Cause: Multiple beans with same name
Solution: Enable overriding or rename beans

Error: "UnsatisfiedDependencyException"

Cause: Required dependency not in context
Solution: Add missing configuration to withUserConfiguration()

Error: "NoSuchBeanDefinitionException"

Cause: Bean expected but not created (likely conditional not met)
Debug: Check @Conditional* annotations and their conditions

Error: "BeanCurrentlyInCreationException"

Cause: Circular dependency detected
Solution: Use withAllowCircularReferences(true) or refactor

Performance Tips

Reuse Base Runners: Create base runner with common configuration
Avoid Full Bootstrapping: Use context runners instead of @SpringBootTest for faster tests
Filter Aggressively: Use FilteredClassLoader to test minimal classpath scenarios
Cache Runners: Define static final runners for reuse across tests
Minimize Bean Creation: Only configure necessary beans for each test