Commit 4b744bdf authored by Phillip Webb's avatar Phillip Webb

Merge pull request #17491 from dreis2211

* pr/17491:
  Delete ModifiedClassPathRunner
  Polish ModifiedClassPath support
  Migrate ModifiedClassPath tests to JUnit 5
  Add JUnit 5 ModifiedClassPathExtension
  Extract ModifiedClassPathClass logic
  Migrate to MockRestServiceServer
  Polish LoggingApplicationListenerTests
  Migrate to ApplicationContextRunner

Closes gh-17491
parents 0cb6a7f4 13b39cbb
......@@ -18,14 +18,14 @@ package org.springframework.boot.actuate.autoconfigure.metrics;
import io.micrometer.core.instrument.binder.logging.Log4j2Metrics;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.actuate.autoconfigure.metrics.test.MetricsRun;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathOverrides;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
......@@ -36,22 +36,22 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathOverrides("org.apache.logging.log4j:log4j-core:2.11.1")
public class Log4J2MetricsWithLog4jLoggerContextAutoConfigurationTests {
class Log4J2MetricsWithLog4jLoggerContextAutoConfigurationTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().with(MetricsRun.simple())
.withConfiguration(AutoConfigurations.of(Log4J2MetricsAutoConfiguration.class));
@Test
public void autoConfiguresLog4J2Metrics() {
void autoConfiguresLog4J2Metrics() {
assertThat(LogManager.getContext().getClass().getName())
.isEqualTo("org.apache.logging.log4j.core.LoggerContext");
this.contextRunner.run((context) -> assertThat(context).hasSingleBean(Log4j2Metrics.class));
}
@Test
public void allowsCustomLog4J2MetricsToBeUsed() {
void allowsCustomLog4J2MetricsToBeUsed() {
assertThat(LogManager.getContext().getClass().getName())
.isEqualTo("org.apache.logging.log4j.core.LoggerContext");
this.contextRunner.withUserConfiguration(CustomLog4J2MetricsConfiguration.class).run(
......
......@@ -17,13 +17,13 @@
package org.springframework.boot.actuate.autoconfigure.metrics;
import io.micrometer.core.instrument.binder.logging.LogbackMetrics;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathOverrides;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -33,15 +33,15 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathOverrides({ "org.apache.logging.log4j:log4j-core:2.9.0", "org.apache.logging.log4j:log4j-slf4j-impl:2.9.0" })
public class MetricsAutoConfigurationWithLog4j2AndLogbackTests {
class MetricsAutoConfigurationWithLog4j2AndLogbackTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(MetricsAutoConfiguration.class));
@Test
public void doesNotConfigureLogbackMetrics() {
void doesNotConfigureLogbackMetrics() {
this.contextRunner.run((context) -> assertThat(context).doesNotHaveBean(LogbackMetrics.class));
}
......
......@@ -16,8 +16,8 @@
package org.springframework.boot.actuate.autoconfigure.redis;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.actuate.autoconfigure.health.HealthIndicatorAutoConfiguration;
import org.springframework.boot.actuate.health.ApplicationHealthIndicator;
......@@ -27,7 +27,7 @@ import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -36,22 +36,22 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Phillip Webb
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions({ "reactor-core*.jar", "lettuce-core*.jar" })
public class RedisHealthIndicatorAutoConfigurationTests {
class RedisHealthIndicatorAutoConfigurationTests {
private ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(RedisAutoConfiguration.class,
RedisHealthIndicatorAutoConfiguration.class, HealthIndicatorAutoConfiguration.class));
@Test
public void runShouldCreateIndicator() {
void runShouldCreateIndicator() {
this.contextRunner.run((context) -> assertThat(context).hasSingleBean(RedisHealthIndicator.class)
.doesNotHaveBean(RedisReactiveHealthIndicator.class).doesNotHaveBean(ApplicationHealthIndicator.class));
}
@Test
public void runWhenDisabledShouldNotCreateIndicator() {
void runWhenDisabledShouldNotCreateIndicator() {
this.contextRunner.withPropertyValues("management.health.redis.enabled:false")
.run((context) -> assertThat(context).doesNotHaveBean(RedisHealthIndicator.class)
.doesNotHaveBean(RedisReactiveHealthIndicator.class)
......
......@@ -18,8 +18,8 @@ package org.springframework.boot.actuate.autoconfigure.web.jersey;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.servlet.ServletContainer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.jersey.ResourceConfigCustomizer;
......@@ -28,7 +28,7 @@ import org.springframework.boot.test.context.FilteredClassLoader;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
......@@ -43,15 +43,15 @@ import static org.mockito.Mockito.verify;
* @author Andy Wilkinson
* @author Madhura Bhave
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("spring-webmvc-*")
public class JerseyChildManagementContextConfigurationTests {
class JerseyChildManagementContextConfigurationTests {
private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withUserConfiguration(JerseyChildManagementContextConfiguration.class);
@Test
public void autoConfigurationIsConditionalOnServletWebApplication() {
void autoConfigurationIsConditionalOnServletWebApplication() {
ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(JerseySameManagementContextConfiguration.class));
contextRunner
......@@ -59,13 +59,13 @@ public class JerseyChildManagementContextConfigurationTests {
}
@Test
public void autoConfigurationIsConditionalOnClassResourceConfig() {
void autoConfigurationIsConditionalOnClassResourceConfig() {
this.contextRunner.withClassLoader(new FilteredClassLoader(ResourceConfig.class))
.run((context) -> assertThat(context).doesNotHaveBean(JerseySameManagementContextConfiguration.class));
}
@Test
public void resourceConfigIsCustomizedWithResourceConfigCustomizerBean() {
void resourceConfigIsCustomizedWithResourceConfigCustomizerBean() {
this.contextRunner.withUserConfiguration(CustomizerConfiguration.class).run((context) -> {
assertThat(context).hasSingleBean(ResourceConfig.class);
ResourceConfig config = context.getBean(ResourceConfig.class);
......@@ -75,7 +75,7 @@ public class JerseyChildManagementContextConfigurationTests {
}
@Test
public void jerseyApplicationPathIsAutoConfigured() {
void jerseyApplicationPathIsAutoConfigured() {
this.contextRunner.run((context) -> {
JerseyApplicationPath bean = context.getBean(JerseyApplicationPath.class);
assertThat(bean.getPath()).isEqualTo("/");
......@@ -84,7 +84,7 @@ public class JerseyChildManagementContextConfigurationTests {
@Test
@SuppressWarnings("unchecked")
public void servletRegistrationBeanIsAutoConfigured() {
void servletRegistrationBeanIsAutoConfigured() {
this.contextRunner.run((context) -> {
ServletRegistrationBean<ServletContainer> bean = context.getBean(ServletRegistrationBean.class);
assertThat(bean.getUrlMappings()).containsExactly("/*");
......@@ -92,7 +92,7 @@ public class JerseyChildManagementContextConfigurationTests {
}
@Test
public void resourceConfigCustomizerBeanIsNotRequired() {
void resourceConfigCustomizerBeanIsNotRequired() {
this.contextRunner.run((context) -> assertThat(context).hasSingleBean(ResourceConfig.class));
}
......
......@@ -17,8 +17,8 @@ package org.springframework.boot.actuate.autoconfigure.web.jersey;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.servlet.ServletContainer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.jersey.ResourceConfigCustomizer;
......@@ -28,7 +28,7 @@ import org.springframework.boot.test.context.FilteredClassLoader;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
......@@ -42,15 +42,15 @@ import static org.mockito.Mockito.verify;
*
* @author Madhura Bhave
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("spring-webmvc-*")
public class JerseySameManagementContextConfigurationTests {
class JerseySameManagementContextConfigurationTests {
private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(JerseySameManagementContextConfiguration.class));
@Test
public void autoConfigurationIsConditionalOnServletWebApplication() {
void autoConfigurationIsConditionalOnServletWebApplication() {
ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(JerseySameManagementContextConfiguration.class));
contextRunner
......@@ -58,13 +58,13 @@ public class JerseySameManagementContextConfigurationTests {
}
@Test
public void autoConfigurationIsConditionalOnClassResourceConfig() {
void autoConfigurationIsConditionalOnClassResourceConfig() {
this.contextRunner.withClassLoader(new FilteredClassLoader(ResourceConfig.class))
.run((context) -> assertThat(context).doesNotHaveBean(JerseySameManagementContextConfiguration.class));
}
@Test
public void resourceConfigIsCustomizedWithResourceConfigCustomizerBean() {
void resourceConfigIsCustomizedWithResourceConfigCustomizerBean() {
this.contextRunner.withUserConfiguration(CustomizerConfiguration.class).run((context) -> {
assertThat(context).hasSingleBean(ResourceConfig.class);
ResourceConfig config = context.getBean(ResourceConfig.class);
......@@ -74,12 +74,12 @@ public class JerseySameManagementContextConfigurationTests {
}
@Test
public void jerseyApplicationPathIsAutoConfiguredWhenNeeded() {
void jerseyApplicationPathIsAutoConfiguredWhenNeeded() {
this.contextRunner.run((context) -> assertThat(context).hasSingleBean(DefaultJerseyApplicationPath.class));
}
@Test
public void jerseyApplicationPathIsConditionalOnMissingBean() {
void jerseyApplicationPathIsConditionalOnMissingBean() {
this.contextRunner.withUserConfiguration(ConfigWithJerseyApplicationPath.class).run((context) -> {
assertThat(context).hasSingleBean(JerseyApplicationPath.class);
assertThat(context).hasBean("testJerseyApplicationPath");
......@@ -87,7 +87,7 @@ public class JerseySameManagementContextConfigurationTests {
}
@Test
public void existingResourceConfigBeanShouldNotAutoConfigureRelatedBeans() {
void existingResourceConfigBeanShouldNotAutoConfigureRelatedBeans() {
this.contextRunner.withUserConfiguration(ConfigWithResourceConfig.class).run((context) -> {
assertThat(context).hasSingleBean(ResourceConfig.class);
assertThat(context).doesNotHaveBean(JerseyApplicationPath.class);
......@@ -98,7 +98,7 @@ public class JerseySameManagementContextConfigurationTests {
@Test
@SuppressWarnings("unchecked")
public void servletRegistrationBeanIsAutoConfiguredWhenNeeded() {
void servletRegistrationBeanIsAutoConfiguredWhenNeeded() {
this.contextRunner.withPropertyValues("spring.jersey.application-path=/jersey").run((context) -> {
ServletRegistrationBean<ServletContainer> bean = context.getBean(ServletRegistrationBean.class);
assertThat(bean.getUrlMappings()).containsExactly("/jersey/*");
......
......@@ -16,8 +16,8 @@
package org.springframework.boot.autoconfigure.batch;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.batch.core.configuration.annotation.BatchConfigurer;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
......@@ -29,7 +29,7 @@ import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
......@@ -41,7 +41,7 @@ import static org.mockito.Mockito.mock;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("spring-jdbc-*.jar")
class BatchAutoConfigurationWithoutJdbcTests {
......
......@@ -18,8 +18,8 @@ package org.springframework.boot.autoconfigure.batch;
import javax.sql.DataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
......@@ -34,7 +34,7 @@ import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfigu
import org.springframework.boot.jdbc.DataSourceInitializationMode;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.PlatformTransactionManager;
......@@ -45,15 +45,15 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("hibernate-jpa-*.jar")
public class BatchAutoConfigurationWithoutJpaTests {
class BatchAutoConfigurationWithoutJpaTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(BatchAutoConfiguration.class, TransactionAutoConfiguration.class));
@Test
public void jdbcWithDefaultSettings() {
void jdbcWithDefaultSettings() {
this.contextRunner.withUserConfiguration(DefaultConfiguration.class, EmbeddedDataSourceConfiguration.class)
.withPropertyValues("spring.datasource.generate-unique-name=true").run((context) -> {
assertThat(context).hasSingleBean(JobLauncher.class);
......@@ -73,7 +73,7 @@ public class BatchAutoConfigurationWithoutJpaTests {
}
@Test
public void jdbcWithCustomPrefix() {
void jdbcWithCustomPrefix() {
this.contextRunner.withUserConfiguration(DefaultConfiguration.class, EmbeddedDataSourceConfiguration.class)
.withPropertyValues("spring.datasource.generate-unique-name=true",
"spring.batch.schema:classpath:batch/custom-schema-hsql.sql",
......
......@@ -16,8 +16,8 @@
package org.springframework.boot.autoconfigure.cache;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.DefaultCacheAndCustomizersConfiguration;
......@@ -25,7 +25,7 @@ import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.
import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.EhCacheCustomCacheManager;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -36,15 +36,15 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Stephane Nicoll
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("ehcache-3*.jar")
public class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(CacheAutoConfiguration.class));
@Test
public void ehCacheWithCaches() {
void ehCacheWithCaches() {
this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
.withPropertyValues("spring.cache.type=ehcache").run((context) -> {
EhCacheCacheManager cacheManager = getCacheManager(context, EhCacheCacheManager.class);
......@@ -55,14 +55,14 @@ public class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfig
}
@Test
public void ehCacheWithCustomizers() {
void ehCacheWithCustomizers() {
this.contextRunner.withUserConfiguration(DefaultCacheAndCustomizersConfiguration.class)
.withPropertyValues("spring.cache.type=ehcache")
.run(verifyCustomizers("allCacheManagerCustomizer", "ehcacheCacheManagerCustomizer"));
}
@Test
public void ehCacheWithConfig() {
void ehCacheWithConfig() {
this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
.withPropertyValues("spring.cache.type=ehcache",
"spring.cache.ehcache.config=cache/ehcache-override.xml")
......@@ -73,7 +73,7 @@ public class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfig
}
@Test
public void ehCacheWithExistingCacheManager() {
void ehCacheWithExistingCacheManager() {
this.contextRunner.withUserConfiguration(EhCacheCustomCacheManager.class)
.withPropertyValues("spring.cache.type=ehcache").run((context) -> {
EhCacheCacheManager cacheManager = getCacheManager(context, EhCacheCacheManager.class);
......
......@@ -17,12 +17,12 @@
package org.springframework.boot.autoconfigure.cache;
import org.ehcache.jsr107.EhcacheCachingProvider;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.DefaultCacheConfiguration;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
......@@ -35,12 +35,12 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Stephane Nicoll
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("ehcache-2*.jar")
public class EhCache3CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
class EhCache3CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
@Test
public void ehcache3AsJCacheWithCaches() {
void ehcache3AsJCacheWithCaches() {
String cachingProviderFqn = EhcacheCachingProvider.class.getName();
this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
.withPropertyValues("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn,
......@@ -52,7 +52,7 @@ public class EhCache3CacheAutoConfigurationTests extends AbstractCacheAutoConfig
}
@Test
public void ehcache3AsJCacheWithConfig() {
void ehcache3AsJCacheWithConfig() {
String cachingProviderFqn = EhcacheCachingProvider.class.getName();
String configLocation = "ehcache3.xml";
this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
......
......@@ -16,14 +16,13 @@
package org.springframework.boot.autoconfigure.condition;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
......@@ -36,22 +35,16 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Stephane Nicoll
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("spring-context-support-*.jar")
public class ConditionalOnMissingBeanWithFilteredClasspathTests {
class ConditionalOnMissingBeanWithFilteredClasspathTests {
private final AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
@After
public void closeContext() {
this.context.close();
}
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withUserConfiguration(OnBeanTypeConfiguration.class);
@Test
public void testNameOnMissingBeanTypeWithMissingImport() {
this.context.register(OnBeanTypeConfiguration.class);
this.context.refresh();
assertThat(this.context.containsBean("foo")).isTrue();
void testNameOnMissingBeanTypeWithMissingImport() {
this.contextRunner.run((context) -> assertThat(context).hasBean("foo"));
}
@Configuration(proxyBeanMethods = false)
......
......@@ -17,12 +17,12 @@
package org.springframework.boot.autoconfigure.condition;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.condition.OnBeanCondition.BeanTypeDeductionException;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
......@@ -38,12 +38,12 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("jackson-core-*.jar")
public class OnBeanConditionTypeDeductionFailureTests {
class OnBeanConditionTypeDeductionFailureTests {
@Test
public void conditionalOnMissingBeanWithDeducedTypeThatIsPartiallyMissingFromClassPath() {
void conditionalOnMissingBeanWithDeducedTypeThatIsPartiallyMissingFromClassPath() {
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> new AnnotationConfigApplicationContext(ImportingConfiguration.class).close())
.satisfies((ex) -> {
......
......@@ -16,15 +16,15 @@
package org.springframework.boot.autoconfigure.data.redis;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration.JedisClientConfigurationBuilder;
......@@ -38,15 +38,15 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Mark Paluch
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("lettuce-core-*.jar")
public class RedisAutoConfigurationJedisTests {
class RedisAutoConfigurationJedisTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(RedisAutoConfiguration.class));
@Test
public void testOverrideRedisConfiguration() {
void testOverrideRedisConfiguration() {
this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.database:1").run((context) -> {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("foo");
......@@ -57,7 +57,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testCustomizeRedisConfiguration() {
void testCustomizeRedisConfiguration() {
this.contextRunner.withUserConfiguration(CustomConfiguration.class).run((context) -> {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
assertThat(cf.isUseSsl()).isTrue();
......@@ -65,7 +65,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testRedisUrlConfiguration() {
void testRedisUrlConfiguration() {
this.contextRunner
.withPropertyValues("spring.redis.host:foo", "spring.redis.url:redis://user:password@example:33")
.run((context) -> {
......@@ -78,7 +78,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testOverrideUrlRedisConfiguration() {
void testOverrideUrlRedisConfiguration() {
this.contextRunner
.withPropertyValues("spring.redis.host:foo", "spring.redis.password:xyz", "spring.redis.port:1000",
"spring.redis.ssl:false", "spring.redis.url:rediss://user:password@example:33")
......@@ -92,7 +92,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testPasswordInUrlWithColon() {
void testPasswordInUrlWithColon() {
this.contextRunner.withPropertyValues("spring.redis.url:redis://:pass:word@example:33").run((context) -> {
assertThat(context.getBean(JedisConnectionFactory.class).getHostName()).isEqualTo("example");
assertThat(context.getBean(JedisConnectionFactory.class).getPort()).isEqualTo(33);
......@@ -101,7 +101,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testPasswordInUrlStartsWithColon() {
void testPasswordInUrlStartsWithColon() {
this.contextRunner.withPropertyValues("spring.redis.url:redis://user::pass:word@example:33").run((context) -> {
assertThat(context.getBean(JedisConnectionFactory.class).getHostName()).isEqualTo("example");
assertThat(context.getBean(JedisConnectionFactory.class).getPort()).isEqualTo(33);
......@@ -110,7 +110,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testRedisConfigurationWithPool() {
void testRedisConfigurationWithPool() {
this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.jedis.pool.min-idle:1",
"spring.redis.jedis.pool.max-idle:4", "spring.redis.jedis.pool.max-active:16",
"spring.redis.jedis.pool.max-wait:2000", "spring.redis.jedis.pool.time-between-eviction-runs:30000")
......@@ -126,7 +126,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testRedisConfigurationWithTimeout() {
void testRedisConfigurationWithTimeout() {
this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.timeout:100").run((context) -> {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("foo");
......@@ -135,7 +135,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testRedisConfigurationWithClientName() {
void testRedisConfigurationWithClientName() {
this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.client-name:spring-boot")
.run((context) -> {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
......@@ -145,7 +145,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testRedisConfigurationWithSentinel() {
void testRedisConfigurationWithSentinel() {
this.contextRunner
.withPropertyValues("spring.redis.sentinel.master:mymaster",
"spring.redis.sentinel.nodes:127.0.0.1:26379,127.0.0.1:26380")
......@@ -156,7 +156,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testRedisConfigurationWithSentinelAndPassword() {
void testRedisConfigurationWithSentinelAndPassword() {
this.contextRunner
.withPropertyValues("spring.redis.password=password", "spring.redis.sentinel.master:mymaster",
"spring.redis.sentinel.nodes:127.0.0.1:26379,127.0.0.1:26380")
......@@ -168,7 +168,7 @@ public class RedisAutoConfigurationJedisTests {
}
@Test
public void testRedisConfigurationWithCluster() {
void testRedisConfigurationWithCluster() {
this.contextRunner.withPropertyValues("spring.redis.cluster.nodes=127.0.0.1:27379,127.0.0.1:27380")
.run((context) -> assertThat(context.getBean(JedisConnectionFactory.class).getClusterConnection())
.isNotNull());
......
......@@ -16,14 +16,14 @@
package org.springframework.boot.autoconfigure.hateoas;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
import org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration;
import org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.boot.web.servlet.context.AnnotationConfigServletWebApplicationContext;
import org.springframework.mock.web.MockServletContext;
......@@ -32,14 +32,14 @@ import org.springframework.mock.web.MockServletContext;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("jackson-*.jar")
public class HypermediaAutoConfigurationWithoutJacksonTests {
class HypermediaAutoConfigurationWithoutJacksonTests {
private AnnotationConfigServletWebApplicationContext context;
@Test
public void jacksonRelatedConfigurationBacksOff() {
void jacksonRelatedConfigurationBacksOff() {
this.context = new AnnotationConfigServletWebApplicationContext();
this.context.register(BaseConfig.class);
this.context.setServletContext(new MockServletContext());
......
......@@ -22,8 +22,8 @@ import com.hazelcast.config.Config;
import com.hazelcast.config.QueueConfig;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.autoconfigure.AutoConfigurations;
......@@ -31,7 +31,7 @@ import org.springframework.boot.test.context.assertj.AssertableApplicationContex
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.test.context.runner.ContextConsumer;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
......@@ -43,15 +43,15 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("hazelcast-client-*.jar")
public class HazelcastAutoConfigurationServerTests {
class HazelcastAutoConfigurationServerTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class));
@Test
public void defaultConfigFile() {
void defaultConfigFile() {
// hazelcast.xml present in root classpath
this.contextRunner.run((context) -> {
Config config = context.getBean(HazelcastInstance.class).getConfig();
......@@ -60,7 +60,7 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void systemPropertyWithXml() {
void systemPropertyWithXml() {
this.contextRunner
.withSystemProperties(HazelcastServerConfiguration.CONFIG_SYSTEM_PROPERTY
+ "=classpath:org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml")
......@@ -71,7 +71,7 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void systemPropertyWithYaml() {
void systemPropertyWithYaml() {
this.contextRunner
.withSystemProperties(HazelcastServerConfiguration.CONFIG_SYSTEM_PROPERTY
+ "=classpath:org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.yaml")
......@@ -82,7 +82,7 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void explicitConfigFileWithXml() {
void explicitConfigFileWithXml() {
this.contextRunner
.withPropertyValues("spring.hazelcast.config=org/springframework/boot/autoconfigure/hazelcast/"
+ "hazelcast-specific.xml")
......@@ -91,7 +91,7 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void explicitConfigFileWithYaml() {
void explicitConfigFileWithYaml() {
this.contextRunner
.withPropertyValues("spring.hazelcast.config=org/springframework/boot/autoconfigure/hazelcast/"
+ "hazelcast-specific.yaml")
......@@ -100,7 +100,7 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void explicitConfigUrlWithXml() {
void explicitConfigUrlWithXml() {
this.contextRunner
.withPropertyValues("spring.hazelcast.config=classpath:org/springframework/"
+ "boot/autoconfigure/hazelcast/hazelcast-specific.xml")
......@@ -109,7 +109,7 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void explicitConfigUrlWithYaml() {
void explicitConfigUrlWithYaml() {
this.contextRunner
.withPropertyValues("spring.hazelcast.config=classpath:org/springframework/"
+ "boot/autoconfigure/hazelcast/hazelcast-specific.yaml")
......@@ -125,14 +125,14 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void unknownConfigFile() {
void unknownConfigFile() {
this.contextRunner.withPropertyValues("spring.hazelcast.config=foo/bar/unknown.xml")
.run((context) -> assertThat(context).getFailure().isInstanceOf(BeanCreationException.class)
.hasMessageContaining("foo/bar/unknown.xml"));
}
@Test
public void configInstanceWithName() {
void configInstanceWithName() {
Config config = new Config("my-test-instance");
HazelcastInstance existing = Hazelcast.newHazelcastInstance(config);
try {
......@@ -150,7 +150,7 @@ public class HazelcastAutoConfigurationServerTests {
}
@Test
public void configInstanceWithoutName() {
void configInstanceWithoutName() {
this.contextRunner.withUserConfiguration(HazelcastConfigNoName.class)
.withPropertyValues("spring.hazelcast.config=this-is-ignored.xml").run((context) -> {
Config config = context.getBean(HazelcastInstance.class).getConfig();
......
......@@ -16,13 +16,13 @@
package org.springframework.boot.autoconfigure.http;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -32,24 +32,16 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("jackson-*.jar")
public class HttpMessageConvertersAutoConfigurationWithoutJacksonTests {
class HttpMessageConvertersAutoConfigurationWithoutJacksonTests {
private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
@After
public void close() {
if (this.context != null) {
this.context.close();
}
}
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(HttpMessageConvertersAutoConfiguration.class));
@Test
public void autoConfigurationWorksWithSpringHateoasButWithoutJackson() {
this.context.register(HttpMessageConvertersAutoConfiguration.class);
this.context.refresh();
assertThat(this.context.getBeansOfType(HttpMessageConverters.class)).hasSize(1);
void autoConfigurationWorksWithSpringHateoasButWithoutJackson() {
this.contextRunner.run((context) -> assertThat(context).hasSingleBean(HttpMessageConverters.class));
}
}
......@@ -16,14 +16,14 @@
package org.springframework.boot.autoconfigure.jdbc;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
import org.springframework.boot.diagnostics.FailureAnalysis;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.mock.env.MockEnvironment;
......@@ -36,14 +36,14 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Andy Wilkinson
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions({ "h2-*.jar", "hsqldb-*.jar" })
public class DataSourceBeanCreationFailureAnalyzerTests {
class DataSourceBeanCreationFailureAnalyzerTests {
private final MockEnvironment environment = new MockEnvironment();
@Test
public void failureAnalysisIsPerformed() {
void failureAnalysisIsPerformed() {
FailureAnalysis failureAnalysis = performAnalysis(TestConfiguration.class);
assertThat(failureAnalysis.getDescription()).contains("'url' attribute is not specified",
"no embedded datasource could be configured", "Failed to determine a suitable driver class");
......@@ -54,7 +54,7 @@ public class DataSourceBeanCreationFailureAnalyzerTests {
}
@Test
public void failureAnalysisIsPerformedWithActiveProfiles() {
void failureAnalysisIsPerformedWithActiveProfiles() {
this.environment.setActiveProfiles("first", "second");
FailureAnalysis failureAnalysis = performAnalysis(TestConfiguration.class);
assertThat(failureAnalysis.getAction()).contains("(the profiles first,second are currently active)");
......
......@@ -18,13 +18,13 @@ package org.springframework.boot.autoconfigure.jsonb;
import javax.json.bind.Jsonb;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -33,15 +33,15 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("johnzon-jsonb-*.jar")
public class JsonbAutoConfigurationWithNoProviderTests {
class JsonbAutoConfigurationWithNoProviderTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(JsonbAutoConfiguration.class));
@Test
public void jsonbBacksOffWhenThereIsNoProvider() {
void jsonbBacksOffWhenThereIsNoProvider() {
this.contextRunner.run((context) -> assertThat(context).doesNotHaveBean(Jsonb.class));
}
......
......@@ -17,15 +17,15 @@
package org.springframework.boot.autoconfigure.orm.jpa;
import org.ehcache.jsr107.EhcacheCachingProvider;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
......@@ -36,9 +36,9 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("ehcache-2*.jar")
public class Hibernate2ndLevelCacheIntegrationTests {
class Hibernate2ndLevelCacheIntegrationTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(CacheAutoConfiguration.class, DataSourceAutoConfiguration.class,
......@@ -47,7 +47,7 @@ public class Hibernate2ndLevelCacheIntegrationTests {
.withUserConfiguration(TestConfiguration.class);
@Test
public void hibernate2ndLevelCacheWithJCacheAndEhCache3() {
void hibernate2ndLevelCacheWithJCacheAndEhCache3() {
String cachingProviderFqn = EhcacheCachingProvider.class.getName();
String configLocation = "ehcache3.xml";
this.contextRunner
......
......@@ -16,13 +16,13 @@
package org.springframework.boot.autoconfigure.session;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.session.web.http.DefaultCookieSerializer;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -33,15 +33,15 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Vedran Pavic
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("spring-security-*")
public class SessionAutoConfigurationWithoutSecurityTests extends AbstractSessionAutoConfigurationTests {
class SessionAutoConfigurationWithoutSecurityTests extends AbstractSessionAutoConfigurationTests {
private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(SessionAutoConfiguration.class));
@Test
public void sessionCookieConfigurationIsAppliedToAutoConfiguredCookieSerializer() {
void sessionCookieConfigurationIsAppliedToAutoConfiguredCookieSerializer() {
this.contextRunner.withUserConfiguration(SessionRepositoryConfiguration.class).run((context) -> {
DefaultCookieSerializer cookieSerializer = context.getBean(DefaultCookieSerializer.class);
assertThat(cookieSerializer).hasFieldOrPropertyWithValue("rememberMeRequestAttribute", null);
......
......@@ -18,13 +18,13 @@ package org.springframework.boot.autoconfigure.validation;
import javax.validation.Validator;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -35,24 +35,19 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions({ "tomcat-embed-el-*.jar", "el-api-*.jar" })
public class ValidationAutoConfigurationWithHibernateValidatorMissingElImplTests {
class ValidationAutoConfigurationWithHibernateValidatorMissingElImplTests {
private AnnotationConfigApplicationContext context;
@After
public void close() {
if (this.context != null) {
this.context.close();
}
}
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(ValidationAutoConfiguration.class));
@Test
public void missingElDependencyIsTolerated() {
this.context = new AnnotationConfigApplicationContext(ValidationAutoConfiguration.class);
assertThat(this.context.getBeansOfType(Validator.class)).hasSize(1);
assertThat(this.context.getBeansOfType(MethodValidationPostProcessor.class)).hasSize(1);
void missingElDependencyIsTolerated() {
this.contextRunner.run((context) -> {
assertThat(context).hasSingleBean(Validator.class);
assertThat(context).hasSingleBean(MethodValidationPostProcessor.class);
});
}
}
......@@ -18,13 +18,13 @@ package org.springframework.boot.autoconfigure.validation;
import javax.validation.Validator;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -34,24 +34,19 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("hibernate-validator-*.jar")
public class ValidationAutoConfigurationWithoutValidatorTests {
class ValidationAutoConfigurationWithoutValidatorTests {
private AnnotationConfigApplicationContext context;
@After
public void close() {
if (this.context != null) {
this.context.close();
}
}
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(ValidationAutoConfiguration.class));
@Test
public void validationIsDisabled() {
this.context = new AnnotationConfigApplicationContext(ValidationAutoConfiguration.class);
assertThat(this.context.getBeansOfType(Validator.class)).isEmpty();
assertThat(this.context.getBeansOfType(MethodValidationPostProcessor.class)).isEmpty();
void validationIsDisabled() {
this.contextRunner.run((context) -> {
assertThat(context).doesNotHaveBean(Validator.class);
assertThat(context).doesNotHaveBean(MethodValidationPostProcessor.class);
});
}
}
......@@ -21,12 +21,12 @@ import java.sql.Statement;
import javax.sql.DataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.ConfigurableApplicationContext;
import static org.mockito.Mockito.never;
......@@ -37,12 +37,12 @@ import static org.mockito.Mockito.verify;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("HikariCP-*.jar")
public class DevToolsEmbeddedDataSourceAutoConfigurationTests extends AbstractDevToolsDataSourceAutoConfigurationTests {
class DevToolsEmbeddedDataSourceAutoConfigurationTests extends AbstractDevToolsDataSourceAutoConfigurationTests {
@Test
public void autoConfiguredDataSourceIsNotShutdown() throws SQLException {
void autoConfiguredDataSourceIsNotShutdown() throws SQLException {
ConfigurableApplicationContext context = createContext(DataSourceAutoConfiguration.class,
DataSourceSpyConfiguration.class);
Statement statement = configureDataSourceBehavior(context.getBean(DataSource.class));
......
......@@ -18,15 +18,15 @@ package org.springframework.boot.test.autoconfigure.orm.jpa;
import javax.sql.DataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.autoconfigure.jdbc.TestDatabaseAutoConfiguration;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
......@@ -40,16 +40,16 @@ import static org.mockito.Mockito.mock;
* @author Stephane Nicoll
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions({ "h2-*.jar", "hsqldb-*.jar", "derby-*.jar" })
public class TestDatabaseAutoConfigurationNoEmbeddedTests {
class TestDatabaseAutoConfigurationNoEmbeddedTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withUserConfiguration(ExistingDataSourceConfiguration.class)
.withConfiguration(AutoConfigurations.of(TestDatabaseAutoConfiguration.class));
@Test
public void applyAnyReplace() {
void applyAnyReplace() {
this.contextRunner.run((context) -> assertThat(context).getFailure().isInstanceOf(BeanCreationException.class)
.hasMessageContaining("Failed to replace DataSource with an embedded database for tests.")
.hasMessageContaining("If you want an embedded database please put a supported one on the classpath")
......@@ -57,7 +57,7 @@ public class TestDatabaseAutoConfigurationNoEmbeddedTests {
}
@Test
public void applyNoReplace() {
void applyNoReplace() {
this.contextRunner.withPropertyValues("spring.test.database.replace=NONE").run((context) -> {
assertThat(context).hasSingleBean(DataSource.class);
assertThat(context).getBean(DataSource.class).isSameAs(context.getBean("myCustomDataSource"));
......
......@@ -16,12 +16,10 @@
package org.springframework.boot.test.autoconfigure.web.client;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.client.MockRestServiceServer;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -33,12 +31,8 @@ import static org.springframework.test.web.client.response.MockRestResponseCreat
*
* @author Phillip Webb
*/
@RunWith(SpringRunner.class)
@RestClientTest(ExampleRestClient.class)
public class RestClientTestWithComponentIntegrationTests {
// JUnit 4 because RestClientTestWithoutJacksonIntegrationTests uses
// ModifiedClassPathRunner
class RestClientTestWithComponentIntegrationTests {
@Autowired
private MockRestServiceServer server;
......@@ -47,7 +41,7 @@ public class RestClientTestWithComponentIntegrationTests {
private ExampleRestClient client;
@Test
public void mockServerCall() {
void mockServerCall() {
this.server.expect(requestTo("/test")).andRespond(withSuccess("hello", MediaType.TEXT_HTML));
assertThat(this.client.test()).isEqualTo("hello");
}
......
......@@ -16,33 +16,42 @@
package org.springframework.boot.test.autoconfigure.web.client;
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.http.MediaType;
import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.util.ClassUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
/**
* Tests for {@link RestClientTest @RestClientTest} without Jackson.
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("jackson-*.jar")
public class RestClientTestWithoutJacksonIntegrationTests {
@RestClientTest(ExampleRestClient.class)
class RestClientTestWithoutJacksonIntegrationTests {
@Autowired
private MockRestServiceServer server;
@Autowired
private ExampleRestClient client;
@Test
public void restClientTestCanBeUsedWhenJacksonIsNotOnTheClassPath() {
assertThat(ClassUtils.isPresent("com.fasterxml.jackson.databind.Module", getClass().getClassLoader()))
.isFalse();
Result result = JUnitCore.runClasses(RestClientTestWithComponentIntegrationTests.class);
assertThat(result.getFailureCount()).isEqualTo(0);
assertThat(result.getRunCount()).isGreaterThan(0);
void restClientTestCanBeUsedWhenJacksonIsNotOnTheClassPath() {
ClassLoader classLoader = getClass().getClassLoader();
assertThat(ClassUtils.isPresent("com.fasterxml.jackson.databind.Module", classLoader)).isFalse();
this.server.expect(requestTo("/test")).andRespond(withSuccess("hello", MediaType.TEXT_HTML));
assertThat(this.client.test()).isEqualTo("hello");
}
}
......@@ -16,13 +16,14 @@
package org.springframework.boot.test.json;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.test.system.OutputCaptureRule;
import org.springframework.boot.testsupport.runner.classpath.ClassPathOverrides;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.boot.testsupport.system.CapturedOutput;
import org.springframework.boot.testsupport.system.OutputCaptureExtension;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -31,15 +32,20 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ExtendWith(OutputCaptureExtension.class)
@ClassPathOverrides("org.json:json:20140107")
public class DuplicateJsonObjectContextCustomizerFactoryTests {
class DuplicateJsonObjectContextCustomizerFactoryTests {
@Rule
public OutputCaptureRule output = new OutputCaptureRule();
private CapturedOutput output;
@BeforeEach
void setup(CapturedOutput output) {
this.output = output;
}
@Test
public void warningForMultipleVersions() {
void warningForMultipleVersions() {
new DuplicateJsonObjectContextCustomizerFactory().createContextCustomizer(null, null).customizeContext(null,
null);
assertThat(this.output).contains("Found multiple occurrences of org.json.JSONObject on the class path:");
......
......@@ -70,6 +70,10 @@
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
</dependency>
<dependency>
<groupId>org.junit.platform</groupId>
<artifactId>junit-platform-launcher</artifactId>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
......
......@@ -24,8 +24,8 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotation used in combination with {@link ModifiedClassPathRunner} to exclude entries
* from the classpath.
* Annotation used in combination with {@link ModifiedClassPathExtension} to exclude
* entries from the classpath.
*
* @author Andy Wilkinson
* @since 1.5.0
......
......@@ -23,8 +23,8 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotation used in combination with {@link ModifiedClassPathRunner} to override entries
* on the classpath.
* Annotation used in combination with {@link ModifiedClassPathExtension} to override
* entries on the classpath.
*
* @author Andy Wilkinson
* @since 1.5.0
......
/*
* Copyright 2012-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.testsupport.runner.classpath;
import java.net.URL;
import java.net.URLClassLoader;
/**
* Custom {@link URLClassLoader} that modifies the class path.
*
* @author Andy Wilkinson
* @author Christoph Dreis
* @see ModifiedClassPathClassLoaderFactory
*/
final class ModifiedClassPathClassLoader extends URLClassLoader {
private final ClassLoader junitLoader;
ModifiedClassPathClassLoader(URL[] urls, ClassLoader parent, ClassLoader junitLoader) {
super(urls, parent);
this.junitLoader = junitLoader;
}
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
if (name.startsWith("org.junit") || name.startsWith("org.hamcrest")) {
return this.junitLoader.loadClass(name);
}
return super.loadClass(name);
}
}
/*
* Copyright 2012-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.testsupport.runner.classpath;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URLClassLoader;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.jupiter.api.extension.Extension;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.InvocationInterceptor;
import org.junit.jupiter.api.extension.ReflectiveInvocationContext;
import org.junit.platform.engine.discovery.DiscoverySelectors;
import org.junit.platform.launcher.Launcher;
import org.junit.platform.launcher.LauncherDiscoveryRequest;
import org.junit.platform.launcher.TestPlan;
import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
import org.junit.platform.launcher.core.LauncherFactory;
import org.junit.platform.launcher.listeners.SummaryGeneratingListener;
import org.junit.platform.launcher.listeners.TestExecutionSummary;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ReflectionUtils;
/**
* A custom {@link Extension} that runs tests using a modified class path. Entries are
* excluded from the class path using {@link ClassPathExclusions @ClassPathExclusions} and
* overridden using {@link ClassPathOverrides @ClassPathOverrides} on the test class. A
* class loader is created with the customized class path and is used both to load the
* test class and as the thread context class loader while the test is being run.
*
* @author Christoph Dreis
* @since 2.2.0
*/
public class ModifiedClassPathExtension implements InvocationInterceptor {
@Override
public void interceptBeforeAllMethod(Invocation<Void> invocation,
ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
intercept(invocation, extensionContext);
}
@Override
public void interceptBeforeEachMethod(Invocation<Void> invocation,
ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
intercept(invocation, extensionContext);
}
@Override
public void interceptAfterEachMethod(Invocation<Void> invocation,
ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
intercept(invocation, extensionContext);
}
@Override
public void interceptAfterAllMethod(Invocation<Void> invocation,
ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
intercept(invocation, extensionContext);
}
@Override
public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext,
ExtensionContext extensionContext) throws Throwable {
if (isModifiedClassPathClassLoader(extensionContext)) {
invocation.proceed();
return;
}
fakeInvocation(invocation);
runTestWithModifiedClassPath(invocationContext, extensionContext);
}
private void runTestWithModifiedClassPath(ReflectiveInvocationContext<Method> invocationContext,
ExtensionContext extensionContext) throws ClassNotFoundException, Throwable {
Class<?> testClass = extensionContext.getRequiredTestClass();
Method testMethod = invocationContext.getExecutable();
ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
URLClassLoader modifiedClassLoader = ModifiedClassPathClassLoaderFactory.createTestClassLoader(testClass);
Thread.currentThread().setContextClassLoader(modifiedClassLoader);
try {
runTest(modifiedClassLoader, testClass.getName(), testMethod.getName());
}
finally {
Thread.currentThread().setContextClassLoader(originalClassLoader);
}
}
private void runTest(URLClassLoader classLoader, String testClassName, String testMethodName)
throws ClassNotFoundException, Throwable {
Class<?> testClass = classLoader.loadClass(testClassName);
Method testMethod = ReflectionUtils.findMethod(testClass, testMethodName);
LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
.selectors(DiscoverySelectors.selectMethod(testClass, testMethod)).build();
Launcher launcher = LauncherFactory.create();
TestPlan testPlan = launcher.discover(request);
SummaryGeneratingListener listener = new SummaryGeneratingListener();
launcher.registerTestExecutionListeners(listener);
launcher.execute(testPlan);
TestExecutionSummary summary = listener.getSummary();
if (!CollectionUtils.isEmpty(summary.getFailures())) {
throw summary.getFailures().get(0).getException();
}
}
private void intercept(Invocation<Void> invocation, ExtensionContext extensionContext) throws Throwable {
if (isModifiedClassPathClassLoader(extensionContext)) {
invocation.proceed();
return;
}
fakeInvocation(invocation);
}
private void fakeInvocation(Invocation<Void> invocation) {
try {
Field field = ReflectionUtils.findField(invocation.getClass(), "invoked");
ReflectionUtils.makeAccessible(field);
ReflectionUtils.setField(field, invocation, new AtomicBoolean(true));
}
catch (Throwable ex) {
}
}
private boolean isModifiedClassPathClassLoader(ExtensionContext extensionContext) {
Class<?> testClass = extensionContext.getRequiredTestClass();
ClassLoader classLoader = testClass.getClassLoader();
return classLoader.getClass().getName().equals(ModifiedClassPathClassLoader.class.getName());
}
}
......@@ -17,35 +17,35 @@
package org.springframework.boot.testsupport.runner.classpath;
import org.hamcrest.Matcher;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.isA;
/**
* Tests for {@link ModifiedClassPathRunner} excluding entries from the class path.
* Tests for {@link ModifiedClassPathExtension} excluding entries from the class path.
*
* @author Andy Wilkinson
* @author Christoph Dreis
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("hibernate-validator-*.jar")
public class ModifiedClassPathRunnerExclusionsTests {
class ModifiedClassPathExtensionExclusionsTests {
private static final String EXCLUDED_RESOURCE = "META-INF/services/javax.validation.spi.ValidationProvider";
private static final String EXCLUDED_RESOURCE = "META-INF/services/" + "javax.validation.spi.ValidationProvider";
@Test
public void entriesAreFilteredFromTestClassClassLoader() {
void entriesAreFilteredFromTestClassClassLoader() {
assertThat(getClass().getClassLoader().getResource(EXCLUDED_RESOURCE)).isNull();
}
@Test
public void entriesAreFilteredFromThreadContextClassLoader() {
void entriesAreFilteredFromThreadContextClassLoader() {
assertThat(Thread.currentThread().getContextClassLoader().getResource(EXCLUDED_RESOURCE)).isNull();
}
@Test
public void testsThatUseHamcrestWorkCorrectly() {
void testsThatUseHamcrestWorkCorrectly() {
Matcher<IllegalStateException> matcher = isA(IllegalStateException.class);
assertThat(matcher.matches(new IllegalStateException())).isTrue();
}
......
......@@ -16,8 +16,8 @@
package org.springframework.boot.testsupport.runner.classpath;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.context.ApplicationContext;
import org.springframework.util.StringUtils;
......@@ -25,22 +25,22 @@ import org.springframework.util.StringUtils;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ModifiedClassPathRunner} overriding entries on the class path.
* Tests for {@link ModifiedClassPathExtension} overriding entries on the class path.
*
* @author Andy Wilkinson
* @author Christoph Dreis
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathOverrides("org.springframework:spring-context:4.1.0.RELEASE")
public class ModifiedClassPathRunnerOverridesTests {
class ModifiedClassPathExtensionOverridesTests {
@Test
public void classesAreLoadedFromOverride() {
void classesAreLoadedFromOverride() {
assertThat(ApplicationContext.class.getProtectionDomain().getCodeSource().getLocation().toString())
.endsWith("spring-context-4.1.0.RELEASE.jar");
}
@Test
public void classesAreLoadedFromTransitiveDependencyOfOverride() {
void classesAreLoadedFromTransitiveDependencyOfOverride() {
assertThat(StringUtils.class.getProtectionDomain().getCodeSource().getLocation().toString())
.endsWith("spring-core-4.1.0.RELEASE.jar");
}
......
......@@ -16,12 +16,11 @@
package org.springframework.boot;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.StaticApplicationContext;
......@@ -33,31 +32,23 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("spring-web*.jar")
public class SpringApplicationNoWebTests {
private ConfigurableApplicationContext context;
@After
public void cleanUp() {
if (this.context != null) {
this.context.close();
}
}
class SpringApplicationNoWebTests {
@Test
public void detectWebApplicationTypeToNone() {
void detectWebApplicationTypeToNone() {
SpringApplication application = new SpringApplication(ExampleConfig.class);
assertThat(application.getWebApplicationType()).isEqualTo(WebApplicationType.NONE);
}
@Test
public void specificApplicationContextClass() {
void specificApplicationContextClass() {
SpringApplication application = new SpringApplication(ExampleConfig.class);
application.setApplicationContextClass(StaticApplicationContext.class);
this.context = application.run();
assertThat(this.context).isInstanceOf(StaticApplicationContext.class);
ConfigurableApplicationContext context = application.run();
assertThat(context).isInstanceOf(StaticApplicationContext.class);
context.close();
}
@Configuration(proxyBeanMethods = false)
......
......@@ -19,12 +19,12 @@ package org.springframework.boot.diagnostics.analyzer;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServlet;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.diagnostics.FailureAnalysis;
import org.springframework.boot.testsupport.runner.classpath.ClassPathOverrides;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
......@@ -34,12 +34,12 @@ import static org.mockito.Mockito.mock;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathOverrides("javax.servlet:servlet-api:2.5")
public class NoSuchMethodFailureAnalyzerTests {
class NoSuchMethodFailureAnalyzerTests {
@Test
public void noSuchMethodErrorIsAnalyzed() {
void noSuchMethodErrorIsAnalyzed() {
Throwable failure = createFailure();
assertThat(failure).isNotNull();
FailureAnalysis analysis = new NoSuchMethodFailureAnalyzer().analyze(failure);
......
......@@ -16,13 +16,13 @@
package org.springframework.boot.diagnostics.analyzer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.validation.annotation.Validated;
......@@ -34,19 +34,19 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
*
* @author Andy Wilkinson
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("hibernate-validator-*.jar")
public class ValidationExceptionFailureAnalyzerTests {
class ValidationExceptionFailureAnalyzerTests {
@Test
public void validatedPropertiesTest() {
void validatedPropertiesTest() {
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> new AnnotationConfigApplicationContext(TestConfiguration.class).close())
.satisfies((ex) -> assertThat(new ValidationExceptionFailureAnalyzer().analyze(ex)).isNotNull());
}
@Test
public void nonValidatedPropertiesTest() {
void nonValidatedPropertiesTest() {
new AnnotationConfigApplicationContext(NonValidatedTestConfiguration.class).close();
}
......
......@@ -16,11 +16,11 @@
package org.springframework.boot.env;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.core.io.ByteArrayResource;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
......@@ -30,14 +30,14 @@ import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
*
* @author Madhura Bhave
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("snakeyaml-*.jar")
public class NoSnakeYamlPropertySourceLoaderTests {
class NoSnakeYamlPropertySourceLoaderTests {
private YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
@Test
public void load() throws Exception {
void load() throws Exception {
ByteArrayResource resource = new ByteArrayResource("foo:\n bar: spam".getBytes());
assertThatIllegalStateException().isThrownBy(() -> this.loader.load("resource", resource))
.withMessageContaining("Attempted to load resource but snakeyaml was not found on the classpath");
......
......@@ -20,12 +20,12 @@ import javax.sql.DataSource;
import com.zaxxer.hikari.HikariDataSource;
import org.apache.tomcat.jdbc.pool.DataSourceProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import static org.assertj.core.api.Assertions.assertThat;
......@@ -34,19 +34,19 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("spring-jdbc-*.jar")
public class DataSourceUnwrapperNoSpringJdbcTests {
class DataSourceUnwrapperNoSpringJdbcTests {
@Test
public void unwrapWithProxy() {
void unwrapWithProxy() {
DataSource dataSource = new HikariDataSource();
DataSource actual = wrapInProxy(wrapInProxy(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, HikariDataSource.class)).isSameAs(dataSource);
}
@Test
public void unwrapDataSourceProxy() {
void unwrapDataSourceProxy() {
org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
DataSource actual = wrapInProxy(wrapInProxy(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, DataSourceProxy.class)).isSameAs(dataSource);
......
......@@ -21,11 +21,11 @@ import javax.validation.Validation;
import javax.validation.ValidationException;
import org.hibernate.validator.messageinterpolation.ParameterMessageInterpolator;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
......@@ -35,12 +35,12 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
*
* @author Phillip Webb
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("tomcat-embed-el-*.jar")
public class MessageInterpolatorFactoryWithoutElIntegrationTests {
class MessageInterpolatorFactoryWithoutElIntegrationTests {
@Test
public void defaultMessageInterpolatorShouldFail() {
void defaultMessageInterpolatorShouldFail() {
// Sanity test
assertThatExceptionOfType(ValidationException.class)
.isThrownBy(Validation.byDefaultProvider().configure()::getDefaultMessageInterpolator)
......@@ -48,7 +48,7 @@ public class MessageInterpolatorFactoryWithoutElIntegrationTests {
}
@Test
public void getObjectShouldUseFallback() {
void getObjectShouldUseFallback() {
MessageInterpolator interpolator = new MessageInterpolatorFactory().getObject();
assertThat(interpolator).isInstanceOf(ParameterMessageInterpolator.class);
}
......
......@@ -19,11 +19,11 @@ package org.springframework.boot.webservices.client;
import java.time.Duration;
import okhttp3.OkHttpClient;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.test.util.ReflectionTestUtils;
......@@ -38,20 +38,20 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions("httpclient-*.jar")
public class HttpWebServiceMessageSenderBuilderOkHttp3IntegrationTests {
class HttpWebServiceMessageSenderBuilderOkHttp3IntegrationTests {
private final HttpWebServiceMessageSenderBuilder builder = new HttpWebServiceMessageSenderBuilder();
@Test
public void buildUseOkHttp3ByDefault() {
void buildUseOkHttp3ByDefault() {
WebServiceMessageSender messageSender = this.builder.build();
assertOkHttp3RequestFactory(messageSender);
}
@Test
public void buildWithCustomTimeouts() {
void buildWithCustomTimeouts() {
WebServiceMessageSender messageSender = this.builder.setConnectTimeout(Duration.ofSeconds(5))
.setReadTimeout(Duration.ofSeconds(2)).build();
OkHttp3ClientHttpRequestFactory factory = assertOkHttp3RequestFactory(messageSender);
......
......@@ -18,11 +18,11 @@ package org.springframework.boot.webservices.client;
import java.time.Duration;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.ws.transport.WebServiceMessageSender;
......@@ -36,20 +36,20 @@ import static org.assertj.core.api.Assertions.assertThat;
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ExtendWith(ModifiedClassPathExtension.class)
@ClassPathExclusions({ "httpclient-*.jar", "okhttp*.jar" })
public class HttpWebServiceMessageSenderBuilderSimpleIntegrationTests {
class HttpWebServiceMessageSenderBuilderSimpleIntegrationTests {
private final HttpWebServiceMessageSenderBuilder builder = new HttpWebServiceMessageSenderBuilder();
@Test
public void buildUseUseSimpleClientByDefault() {
void buildUseUseSimpleClientByDefault() {
WebServiceMessageSender messageSender = this.builder.build();
assertSimpleClientRequestFactory(messageSender);
}
@Test
public void buildWithCustomTimeouts() {
void buildWithCustomTimeouts() {
WebServiceMessageSender messageSender = this.builder.setConnectTimeout(Duration.ofSeconds(5))
.setReadTimeout(Duration.ofSeconds(2)).build();
SimpleClientHttpRequestFactory requestFactory = assertSimpleClientRequestFactory(messageSender);
......
......@@ -41,7 +41,6 @@
<suppress files="ModifiedClassPathRunnerExclusionsTests" checks="SpringJUnit5" />
<suppress files="[\\/]src[\\/]test[\\/]java[\\/]org[\\/]springframework[\\/]boot[\\/]test[\\/]rule[\\/]" checks="SpringJUnit5" />
<suppress files="OutputCaptureRuleTests" checks="SpringJUnit5" />
<suppress files="RestClientTestWithComponentIntegrationTests" checks="SpringJUnit5" />
<suppress files="SampleJUnitVintageApplicationTests" checks="SpringJUnit5" />
<suppress files="[\\/]spring-boot-docs[\\/]" checks="SpringJavadoc" message="\@since" />
<suppress files="[\\/]spring-boot-smoke-tests[\\/]" checks="SpringJavadoc" message="\@since" />
......
......@@ -8,9 +8,7 @@
</module>
<module name="io.spring.javaformat.checkstyle.SpringChecks" />
<module name="com.puppycrawl.tools.checkstyle.TreeWalker">
<module name="io.spring.javaformat.checkstyle.check.SpringJUnit5Check">
<property name="unlessImports" value="org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner" />
</module>
<module name="io.spring.javaformat.checkstyle.check.SpringJUnit5Check" />
<module
name="com.puppycrawl.tools.checkstyle.checks.imports.IllegalImportCheck">
<property name="regexp" value="true" />
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment