Allow @ContextConfiguration to be omitted

Prior to this commit, the @ContextConfiguration annotation was required to be present even if default XML files, Groovy scripts, or @configuration classes were detected; however, in such cases the @ContextConfiguration was typically declared empty and therefore seemingly unnecessary boilerplate. This commit permits @ContextConfiguration to be omitted whenever it can be reasonably deduced. Consequently, integration tests such as the following are now supported. @RunWith(SpringRunner.class) public class MyTest { @Autowired String myBean; @test public void example() { /* ... */ } @configuration static class Config { @bean String myBean() { return "Hello"; } } } Issue: SPR-13955

Author: philwebb

spring-test/src/main/java/org/springframework/test/context/ContextConfigurationAttributes.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2016 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.
@@ -34,6 +34,7 @@
  * attributes declared via {@link ContextConfiguration @ContextConfiguration}.
  *
  * @author Sam Brannen
+ * @author Phillip Webb
  * @since 3.1
  * @see ContextConfiguration
  * @see SmartContextLoader#processContextConfiguration(ContextConfigurationAttributes)
@@ -43,6 +44,10 @@ public class ContextConfigurationAttributes {
 
 private static final Log logger = LogFactory.getLog(ContextConfigurationAttributes.class);
 
+private static final String[] EMPTY_LOCATIONS = new String[0];
+
+private static final Class<?>[] EMPTY_CLASSES = new Class<?>[0];
+
 private final Class<?> declaringClass;
 
 private Class<?>[] classes;
@@ -60,6 +65,18 @@ public class ContextConfigurationAttributes {
 private final Class<? extends ContextLoader> contextLoaderClass;
 
 
+/**
+ * Construct a new {@link ContextConfigurationAttributes} instance with default
+ * values.
+ * @param declaringClass the test class that declared {@code @ContextConfiguration},
+ * either explicitly or implicitly
+ * @since 4.3
+ */
+@SuppressWarnings("unchecked")
+public ContextConfigurationAttributes(Class<?> declaringClass) {
+this(declaringClass, EMPTY_LOCATIONS, EMPTY_CLASSES, false, (Class[]) EMPTY_CLASSES, true, ContextLoader.class);
+}
+
 /**
  * Construct a new {@link ContextConfigurationAttributes} instance for the
  * supplied {@link ContextConfiguration @ContextConfiguration} annotation and
@@ -158,7 +175,8 @@ public ContextConfigurationAttributes(
 
 /**
  * Get the {@linkplain Class class} that declared the
- * {@link ContextConfiguration @ContextConfiguration} annotation.
+ * {@link ContextConfiguration @ContextConfiguration} annotation, either explicitly
+ * or implicitly.
  * @return the declaring class (never {@code null})
  */
 public Class<?> getDeclaringClass() {

spring-test/src/main/java/org/springframework/test/context/support/AbstractDelegatingSmartContextLoader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2016 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.
@@ -29,7 +29,6 @@
 import org.springframework.test.context.MergedContextConfiguration;
 import org.springframework.test.context.SmartContextLoader;
 import org.springframework.util.Assert;
-import org.springframework.util.ObjectUtils;
 
 /**
  * {@code AbstractDelegatingSmartContextLoader} serves as an abstract base class
@@ -202,15 +201,6 @@ else if (configAttributes.hasClasses()) {
 name(getAnnotationConfigLoader()), configAttributes));
 }
 
-// If neither loader detected defaults and no initializers were declared,
-// throw an exception.
-if (!configAttributes.hasResources() && ObjectUtils.isEmpty(configAttributes.getInitializers())) {
-throw new IllegalStateException(String.format(
-"Neither %s nor %s was able to detect defaults, and no ApplicationContextInitializers "
-+ "were declared for context configuration %s", name(getXmlLoader()),
-name(getAnnotationConfigLoader()), configAttributes));
-}
-
 if (configAttributes.hasLocations() && configAttributes.hasClasses()) {
 String message = String.format(
 "Configuration error: both default locations AND default configuration classes "

spring-test/src/main/java/org/springframework/test/context/support/AbstractTestContextBootstrapper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2016 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.
@@ -18,6 +18,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
@@ -30,8 +31,6 @@
 
 import org.springframework.beans.BeanInstantiationException;
 import org.springframework.beans.BeanUtils;
-import org.springframework.context.ApplicationContextInitializer;
-import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.io.support.SpringFactoriesLoader;
@@ -71,6 +70,7 @@
  *
  * @author Sam Brannen
  * @author Juergen Hoeller
+ * @author Phillip Webb
  * @since 4.1
  */
 public abstract class AbstractTestContextBootstrapper implements TestContextBootstrapper {
@@ -272,13 +272,8 @@ public final MergedContextConfiguration buildMergedContextConfiguration() {
 CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate = getCacheAwareContextLoaderDelegate();
 
 if (MetaAnnotationUtils.findAnnotationDescriptorForTypes(testClass, ContextConfiguration.class,
-ContextHierarchy.class) == null) {
-if (logger.isInfoEnabled()) {
-logger.info(String.format(
-"Neither @ContextConfiguration nor @ContextHierarchy found for test class [%s]",
-testClass.getName()));
-}
-return new MergedContextConfiguration(testClass, null, null, null, null);
+ContextHierarchy.class) == null) {
+return buildDefaultMergedContextConfiguration(testClass, cacheAwareContextLoaderDelegate);
 }
 
 if (AnnotationUtils.findAnnotation(testClass, ContextHierarchy.class) != null) {
@@ -297,7 +292,7 @@ public final MergedContextConfiguration buildMergedContextConfiguration() {
 Class<?> declaringClass = reversedList.get(0).getDeclaringClass();
 
 mergedConfig = buildMergedContextConfiguration(declaringClass, reversedList, parentConfig,
-cacheAwareContextLoaderDelegate);
+cacheAwareContextLoaderDelegate, true);
 parentConfig = mergedConfig;
 }
 
@@ -307,10 +302,29 @@ public final MergedContextConfiguration buildMergedContextConfiguration() {
 else {
 return buildMergedContextConfiguration(testClass,
 ContextLoaderUtils.resolveContextConfigurationAttributes(testClass), null,
-cacheAwareContextLoaderDelegate);
+cacheAwareContextLoaderDelegate, true);
 }
 }
 
+/**
+ * @since 4.3
+ */
+private MergedContextConfiguration buildDefaultMergedContextConfiguration(Class<?> testClass,
+CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {
+
+List<ContextConfigurationAttributes> defaultConfigAttributesList
+= Collections.singletonList(new ContextConfigurationAttributes(testClass));
+
+ContextLoader contextLoader = resolveContextLoader(testClass, defaultConfigAttributesList);
+if (logger.isInfoEnabled()) {
+logger.info(String.format(
+"Neither @ContextConfiguration nor @ContextHierarchy found for test class [%s], using %s",
+testClass.getName(), contextLoader.getClass().getSimpleName()));
+}
+return buildMergedContextConfiguration(testClass, defaultConfigAttributesList, null,
+cacheAwareContextLoaderDelegate, false);
+}
+
 /**
  * Build the {@link MergedContextConfiguration merged context configuration}
  * for the supplied {@link Class testClass}, context configuration attributes,
@@ -324,6 +338,9 @@ public final MergedContextConfiguration buildMergedContextConfiguration() {
  * context in a context hierarchy, or {@code null} if there is no parent
  * @param cacheAwareContextLoaderDelegate the cache-aware context loader delegate to
  * be passed to the {@code MergedContextConfiguration} constructor
+ * @param requireLocationsClassesOrInitializers whether locations, classes, or
+ * initializers are required; typically {@code true} but may be set to {@code false}
+ * if the configured loader supports empty configuration
  * @return the merged context configuration
  * @see #resolveContextLoader
  * @see ContextLoaderUtils#resolveContextConfigurationAttributes
@@ -335,11 +352,15 @@ public final MergedContextConfiguration buildMergedContextConfiguration() {
  */
 private MergedContextConfiguration buildMergedContextConfiguration(Class<?> testClass,
 List<ContextConfigurationAttributes> configAttributesList, MergedContextConfiguration parentConfig,
-CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {
+CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate,
+boolean requireLocationsClassesOrInitializers) {
+
+Assert.notEmpty(configAttributesList, "ContextConfigurationAttributes list must not be null or empty");
 
 ContextLoader contextLoader = resolveContextLoader(testClass, configAttributesList);
-List<String> locationsList = new ArrayList<String>();
-List<Class<?>> classesList = new ArrayList<Class<?>>();
+List<String> locations = new ArrayList<String>();
+List<Class<?>> classes = new ArrayList<Class<?>>();
+List<Class<?>> initializers = new ArrayList<Class<?>>();
 
 for (ContextConfigurationAttributes configAttributes : configAttributesList) {
 if (logger.isTraceEnabled()) {
@@ -349,34 +370,53 @@ private MergedContextConfiguration buildMergedContextConfiguration(Class<?> test
 if (contextLoader instanceof SmartContextLoader) {
 SmartContextLoader smartContextLoader = (SmartContextLoader) contextLoader;
 smartContextLoader.processContextConfiguration(configAttributes);
-locationsList.addAll(0, Arrays.asList(configAttributes.getLocations()));
-classesList.addAll(0, Arrays.asList(configAttributes.getClasses()));
+locations.addAll(0, Arrays.asList(configAttributes.getLocations()));
+classes.addAll(0, Arrays.asList(configAttributes.getClasses()));
 }
 else {
-String[] processedLocations = contextLoader.processLocations(configAttributes.getDeclaringClass(),
-configAttributes.getLocations());
-locationsList.addAll(0, Arrays.asList(processedLocations));
+String[] processedLocations = contextLoader.processLocations(
+configAttributes.getDeclaringClass(), configAttributes.getLocations());
+locations.addAll(0, Arrays.asList(processedLocations));
 // Legacy ContextLoaders don't know how to process classes
 }
+initializers.addAll(0, Arrays.asList(configAttributes.getInitializers()));
 if (!configAttributes.isInheritLocations()) {
 break;
 }
 }
 
-String[] locations = StringUtils.toStringArray(locationsList);
-Class<?>[] classes = ClassUtils.toClassArray(classesList);
-Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses = //
-ApplicationContextInitializerUtils.resolveInitializerClasses(configAttributesList);
-String[] activeProfiles = ActiveProfilesUtils.resolveActiveProfiles(testClass);
-MergedTestPropertySources mergedTestPropertySources = TestPropertySourceUtils.buildMergedTestPropertySources(testClass);
+if (requireLocationsClassesOrInitializers && areAllEmpty(locations, classes, initializers)) {
+throw new IllegalStateException(String.format(
+"%s was unable to detect defaults, and no ApplicationContextInitializers "
++ "were declared for context configuration attributes %s",
+contextLoader.getClass().getSimpleName(), configAttributesList));
+}
 
-MergedContextConfiguration mergedConfig = new MergedContextConfiguration(testClass, locations, classes,
-initializerClasses, activeProfiles, mergedTestPropertySources.getLocations(),
-mergedTestPropertySources.getProperties(), contextLoader, cacheAwareContextLoaderDelegate, parentConfig);
+MergedTestPropertySources mergedTestPropertySources = TestPropertySourceUtils.buildMergedTestPropertySources(testClass);
+MergedContextConfiguration mergedConfig = new MergedContextConfiguration(testClass,
+StringUtils.toStringArray(locations),
+ClassUtils.toClassArray(classes),
+ApplicationContextInitializerUtils.resolveInitializerClasses(configAttributesList),
+ActiveProfilesUtils.resolveActiveProfiles(testClass),
+mergedTestPropertySources.getLocations(),
+mergedTestPropertySources.getProperties(),
+contextLoader, cacheAwareContextLoaderDelegate, parentConfig);
 
 return processMergedContextConfiguration(mergedConfig);
 }
 
+/**
+ * @since 4.3
+ */
+private boolean areAllEmpty(Collection<?>... collections) {
+for (Collection<?> collection : collections) {
+if (!collection.isEmpty()) {
+return false;
+}
+}
+return true;
+}
+
 /**
  * Resolve the {@link ContextLoader} {@linkplain Class class} to use for the
  * supplied list of {@link ContextConfigurationAttributes} and then instantiate
@@ -389,7 +429,7 @@ private MergedContextConfiguration buildMergedContextConfiguration(Class<?> test
  * @param testClass the test class for which the {@code ContextLoader} should be
  * resolved; must not be {@code null}
  * @param configAttributesList the list of configuration attributes to process; must
- * not be {@code null} or <em>empty</em>; must be ordered <em>bottom-up</em>
+ * not be {@code null}; must be ordered <em>bottom-up</em>
  * (i.e., as if we were traversing up the class hierarchy)
  * @return the resolved {@code ContextLoader} for the supplied {@code testClass}
  * (never {@code null})
@@ -400,7 +440,7 @@ protected ContextLoader resolveContextLoader(Class<?> testClass,
 List<ContextConfigurationAttributes> configAttributesList) {
 
 Assert.notNull(testClass, "Class must not be null");
-Assert.notEmpty(configAttributesList, "ContextConfigurationAttributes list must not be empty");
+Assert.notNull(configAttributesList, "ContextConfigurationAttributes list must not be null");
 
 Class<? extends ContextLoader> contextLoaderClass = resolveExplicitContextLoaderClass(configAttributesList);
 if (contextLoaderClass == null) {
@@ -429,7 +469,7 @@ protected ContextLoader resolveContextLoader(Class<?> testClass,
  * step #1.</li>
  * </ol>
  * @param configAttributesList the list of configuration attributes to process;
- * must not be {@code null} or <em>empty</em>; must be ordered <em>bottom-up</em>
+ * must not be {@code null}; must be ordered <em>bottom-up</em>
  * (i.e., as if we were traversing up the class hierarchy)
  * @return the {@code ContextLoader} class to use for the supplied configuration
  * attributes, or {@code null} if no explicit loader is found
@@ -439,7 +479,8 @@ protected ContextLoader resolveContextLoader(Class<?> testClass,
 protected Class<? extends ContextLoader> resolveExplicitContextLoaderClass(
 List<ContextConfigurationAttributes> configAttributesList) {
 
-Assert.notEmpty(configAttributesList, "ContextConfigurationAttributes list must not be empty");
+Assert.notNull(configAttributesList, "ContextConfigurationAttributes list must not be null");
+
 for (ContextConfigurationAttributes configAttributes : configAttributesList) {
 if (logger.isTraceEnabled()) {
 logger.trace(String.format("Resolving ContextLoader for context configuration attributes %s",

spring-test/src/test/java/org/springframework/test/context/junit4/OptionalContextConfigurationSpringRunnerTests.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2002-2016 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
+ *
+ * http://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.test.context.junit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * JUnit 4 based integration test which verifies that {@link @ContextConfiguration}
+ * is optional.
+ *
+ * @author Phillip Webb
+ * @author Sam Brannen
+ * @since 4.3
+ */
+@RunWith(SpringRunner.class)
+public class OptionalContextConfigurationSpringRunnerTests {
+
+@Autowired
+String foo;
+
+
+@Test
+public void contextConfigurationAnnotationIsOptional() {
+assertEquals("foo", foo);
+}
+
+
+@Configuration
+static class Config {
+
+@Bean
+String foo() {
+return "foo";
+}
+}
+
+}