Merge pull request #121 from sbrannen/SPR-9011

* SPR-9011:
  Support ApplicationContextInitializers in the TCF

Author: sbrannen

spring-test/.springBeans

@@ -1,13 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beansProjectDescription>
 	<version>1</version>
-	<pluginVersion><![CDATA[2.6.0.201104111100-PATCH]]></pluginVersion>
+	<pluginVersion><![CDATA[3.0.0.201208090952-RELEASE]]></pluginVersion>
 	<configSuffixes>
 		<configSuffix><![CDATA[xml]]></configSuffix>
 	</configSuffixes>
 	<enableImports><![CDATA[false]]></enableImports>
 	<configs>
 		<config>src/test/java/org/springframework/test/context/junit4/profile/xml/DefaultProfileXmlConfigTests-context.xml</config>
+		<config>src/test/java/org/springframework/test/context/junit4/aci/xml/MultipleInitializersXmlConfigTests-context.xml</config>
 	</configs>
 	<configSets>
 	</configSets>

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

@@ -23,19 +23,19 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
 
 /**
- * {@code ContextConfiguration} defines class-level metadata that is
+ * {@code @ContextConfiguration} defines class-level metadata that is
  * used to determine how to load and configure an
  * {@link org.springframework.context.ApplicationContext ApplicationContext}
- * for test classes.
+ * for integration tests.
  *
  * <h3>Supported Resource Types</h3>
  *
  * <p>Prior to Spring 3.1, only path-based resource locations were supported.
- * As of Spring 3.1, {@link #loader context loaders} may choose to support
+ * As of Spring 3.1, {@linkplain #loader context loaders} may choose to support
  * either path-based or class-based resources (but not both). Consequently
  * {@code @ContextConfiguration} can be used to declare either path-based
  * resource locations (via the {@link #locations} or {@link #value}
@@ -47,16 +47,20 @@
  * <p>The term <em>annotated class</em> can refer to any of the following.
  *
  * <ul>
- * <li>A class annotated with {@link Configuration @Configuration}</li>
+ * <li>A class annotated with
+ * {@link org.springframework.context.annotation.Configuration @Configuration}</li>
  * <li>A component (i.e., a class annotated with
  * {@link org.springframework.stereotype.Component @Component},
  * {@link org.springframework.stereotype.Service @Service},
  * {@link org.springframework.stereotype.Repository @Repository}, etc.)</li>
  * <li>A JSR-330 compliant class that is annotated with {@code javax.inject} annotations</li>
- * <li>Any other class that contains {@link Bean @Bean}-methods</li>
+ * <li>Any other class that contains
+ * {@link org.springframework.context.annotation.Bean @Bean}-methods</li>
  * </ul>
  *
- * Consult the JavaDoc for {@link Configuration @Configuration} and {@link Bean @Bean}
+ * Consult the Javadoc for
+ * {@link org.springframework.context.annotation.Configuration @Configuration} and
+ * {@link org.springframework.context.annotation.Bean @Bean}
  * for further information regarding the configuration and semantics of
  * <em>annotated classes</em>.
  *
@@ -66,8 +70,8 @@
  * @see SmartContextLoader
  * @see ContextConfigurationAttributes
  * @see MergedContextConfiguration
- * @see org.springframework.context.ApplicationContext
  * @see ActiveProfiles
+ * @see org.springframework.context.ApplicationContext
  */
 @Documented
 @Inherited
@@ -82,6 +86,7 @@
 	 * with {@link #locations} or {@link #classes}, but it may be used
 	 * instead of {@link #locations}.
 	 * @since 3.0
+	 * @see #inheritLocations
 	 */
 	String[] value() default {};
 
@@ -111,6 +116,7 @@
 	 * {@link #value} or {@link #classes}, but it may be used instead of
 	 * {@link #value}.
 	 * @since 2.5
+	 * @see #inheritLocations
 	 */
 	String[] locations() default {};
 
@@ -131,9 +137,31 @@
 	 * @since 3.1
 	 * @see org.springframework.context.annotation.Configuration
 	 * @see org.springframework.test.context.support.AnnotationConfigContextLoader
+	 * @see #inheritLocations
 	 */
 	Class<?>[] classes() default {};
 
+	/**
+	 * The application context <em>initializer classes</em> to use for initializing
+	 * a {@link ConfigurableApplicationContext}.
+	 * 
+	 * <p>The concrete {@code ConfigurableApplicationContext} type supported by each
+	 * declared initializer must be compatible with the type of {@code ApplicationContext}
+	 * created by the {@link SmartContextLoader} in use.
+	 *
+	 * <p>{@code SmartContextLoader} implementations typically detect whether
+	 * Spring's {@link org.springframework.core.Ordered Ordered} interface has been
+	 * implemented or if the @{@link org.springframework.core.annotation.Order Order}
+	 * annotation is present and sort instances accordingly prior to invoking them.
+	 *
+	 * @since 3.2
+	 * @see org.springframework.context.ApplicationContextInitializer
+	 * @see org.springframework.context.ConfigurableApplicationContext
+	 * @see #inheritInitializers
+	 * @see #loader
+	 */
+	Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>[] initializers() default {};
+
 	/**
 	 * Whether or not {@link #locations resource locations} or <em>annotated
 	 * classes</em> from test superclasses should be <em>inherited</em>.
@@ -194,7 +222,45 @@
 	boolean inheritLocations() default true;
 
 	/**
-	 * The type of {@link ContextLoader} (or {@link SmartContextLoader}) to use
+	 * Whether or not {@linkplain #initializers context initializers} from test
+	 * superclasses should be <em>inherited</em>.
+	 *
+	 * <p>The default value is <code>true</code>. This means that an annotated
+	 * class will <em>inherit</em> the application context initializers defined
+	 * by test superclasses. Specifically, the initializers for a given test
+	 * class will be added to the set of initializers defined by test
+	 * superclasses. Thus, subclasses have the option of <em>extending</em> the
+	 * set of initializers.
+	 *
+	 * <p>If <code>inheritInitializers</code> is set to <code>false</code>, the
+	 * initializers for the annotated class will <em>shadow</em> and effectively
+	 * replace any initializers defined by superclasses.
+	 *
+	 * <p>In the following example, the
+	 * {@link org.springframework.context.ApplicationContext ApplicationContext}
+	 * for {@code ExtendedTest} will be initialized using
+	 * {@code BaseInitializer} <strong>and</strong> {@code ExtendedInitializer}.
+	 * Note, however, that the order in which the initializers are invoked
+	 * depends on whether they implement {@link org.springframework.core.Ordered
+	 * Ordered} or are annotated with {@link org.springframework.core.annotation.Order
+	 * &#064;Order}.
+	 * <pre class="code">
+	 * &#064;ContextConfiguration(initializers = BaseInitializer.class)
+	 * public class BaseTest {
+	 *     // ...
+	 * }
+	 * 
+	 * &#064;ContextConfiguration(initializers = ExtendedInitializer.class)
+	 * public class ExtendedTest extends BaseTest {
+	 *     // ...
+	 * }
+	 * </pre>
+	 * @since 3.2
+	 */
+	boolean inheritInitializers() default true;
+
+	/**
+	 * The type of {@link SmartContextLoader} (or {@link ContextLoader}) to use
 	 * for loading an {@link org.springframework.context.ApplicationContext
 	 * ApplicationContext}.
 	 * 

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

@@ -18,12 +18,15 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.style.ToStringCreator;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 
 /**
- * <code>ContextConfigurationAttributes</code> encapsulates the context
+ * {@code ContextConfigurationAttributes} encapsulates the context
  * configuration attributes declared on a test class via
  * {@link ContextConfiguration @ContextConfiguration}.
  *
@@ -47,6 +50,10 @@ public class ContextConfigurationAttributes {
 
 	private final Class<? extends ContextLoader> contextLoaderClass;
 
+	private final Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>[] initializers;
+
+	private final boolean inheritInitializers;
+
 
 	/**
 	 * Resolve resource locations from the {@link ContextConfiguration#locations() locations}
@@ -68,8 +75,7 @@ private static String[] resolveLocations(Class<?> declaringClass, ContextConfigu
 				ObjectUtils.nullSafeToString(valueLocations), ObjectUtils.nullSafeToString(locations));
 			logger.error(msg);
 			throw new IllegalStateException(msg);
-		}
-		else if (!ObjectUtils.isEmpty(valueLocations)) {
+		} else if (!ObjectUtils.isEmpty(valueLocations)) {
 			locations = valueLocations;
 		}
 
@@ -79,31 +85,59 @@ else if (!ObjectUtils.isEmpty(valueLocations)) {
 	/**
 	 * Construct a new {@link ContextConfigurationAttributes} instance for the
 	 * supplied {@link ContextConfiguration @ContextConfiguration} annotation and
-	 * the {@link Class test class} that declared it.
+	 * the {@linkplain Class test class} that declared it.
 	 * @param declaringClass the test class that declared {@code @ContextConfiguration}
 	 * @param contextConfiguration the annotation from which to retrieve the attributes
 	 */
 	public ContextConfigurationAttributes(Class<?> declaringClass, ContextConfiguration contextConfiguration) {
 		this(declaringClass, resolveLocations(declaringClass, contextConfiguration), contextConfiguration.classes(),
-			contextConfiguration.inheritLocations(), contextConfiguration.loader());
+			contextConfiguration.inheritLocations(), contextConfiguration.initializers(),
+			contextConfiguration.inheritInitializers(), contextConfiguration.loader());
 	}
 
 	/**
 	 * Construct a new {@link ContextConfigurationAttributes} instance for the
-	 * {@link Class test class} that declared the
+	 * {@linkplain Class test class} that declared the
 	 * {@link ContextConfiguration @ContextConfiguration} annotation and its
 	 * corresponding attributes.
 	 *
 	 * @param declaringClass the test class that declared {@code @ContextConfiguration}
 	 * @param locations the resource locations declared via {@code @ContextConfiguration}
 	 * @param classes the annotated classes declared via {@code @ContextConfiguration}
-	 * @param inheritLocations the <code>inheritLocations</code> flag declared via {@code @ContextConfiguration}
+	 * @param inheritLocations the {@code inheritLocations} flag declared via {@code @ContextConfiguration}
 	 * @param contextLoaderClass the {@code ContextLoader} class declared via {@code @ContextConfiguration}
 	 * @throws IllegalArgumentException if the {@code declaringClass} or {@code contextLoaderClass} is
-	 * <code>null</code>, or if the {@code locations} and {@code classes} are both non-empty
+	 * {@code null}, or if the {@code locations} and {@code classes} are both non-empty
+	 * @deprecated as of Spring 3.2, use
+	 * {@link #ContextConfigurationAttributes(Class, String[], Class[], boolean, Class[], boolean, Class)}
+	 * instead
 	 */
+	@Deprecated
 	public ContextConfigurationAttributes(Class<?> declaringClass, String[] locations, Class<?>[] classes,
 			boolean inheritLocations, Class<? extends ContextLoader> contextLoaderClass) {
+		this(declaringClass, locations, classes, inheritLocations, null, true, contextLoaderClass);
+	}
+
+	/**
+	 * Construct a new {@link ContextConfigurationAttributes} instance for the
+	 * {@linkplain Class test class} that declared the
+	 * {@link ContextConfiguration @ContextConfiguration} annotation and its
+	 * corresponding attributes.
+	 *
+	 * @param declaringClass the test class that declared {@code @ContextConfiguration}
+	 * @param locations the resource locations declared via {@code @ContextConfiguration}
+	 * @param classes the annotated classes declared via {@code @ContextConfiguration}
+	 * @param inheritLocations the {@code inheritLocations} flag declared via {@code @ContextConfiguration}
+	 * @param initializers the context initializers declared via {@code @ContextConfiguration}
+	 * @param inheritInitializers the {@code inheritInitializers} flag declared via {@code @ContextConfiguration}
+	 * @param contextLoaderClass the {@code ContextLoader} class declared via {@code @ContextConfiguration}
+	 * @throws IllegalArgumentException if the {@code declaringClass} or {@code contextLoaderClass} is
+	 * {@code null}, or if the {@code locations} and {@code classes} are both non-empty
+	 */
+	public ContextConfigurationAttributes(Class<?> declaringClass, String[] locations, Class<?>[] classes,
+			boolean inheritLocations,
+			Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>[] initializers,
+			boolean inheritInitializers, Class<? extends ContextLoader> contextLoaderClass) {
 
 		Assert.notNull(declaringClass, "declaringClass must not be null");
 		Assert.notNull(contextLoaderClass, "contextLoaderClass must not be null");
@@ -122,14 +156,16 @@ public ContextConfigurationAttributes(Class<?> declaringClass, String[] location
 		this.locations = locations;
 		this.classes = classes;
 		this.inheritLocations = inheritLocations;
+		this.initializers = initializers;
+		this.inheritInitializers = inheritInitializers;
 		this.contextLoaderClass = contextLoaderClass;
 	}
 
 	/**
-	 * Get the {@link Class class} that declared the
+	 * Get the {@linkplain Class class} that declared the
 	 * {@link ContextConfiguration @ContextConfiguration} annotation.
 	 *
-	 * @return the declaring class; never <code>null</code>
+	 * @return the declaring class; never {@code null}
 	 */
 	public Class<?> getDeclaringClass() {
 		return declaringClass;
@@ -143,7 +179,7 @@ public Class<?> getDeclaringClass() {
 	 * represent a <em>processed</em> value that does not match the original value
 	 * declared via {@link ContextConfiguration @ContextConfiguration}.
 	 *
-	 * @return the resource locations; potentially <code>null</code> or <em>empty</em>
+	 * @return the resource locations; potentially {@code null} or <em>empty</em>
 	 * @see ContextConfiguration#value
 	 * @see ContextConfiguration#locations
 	 * @see #setLocations(String[])
@@ -170,7 +206,7 @@ public void setLocations(String[] locations) {
 	 * represent a <em>processed</em> value that does not match the original value
 	 * declared via {@link ContextConfiguration @ContextConfiguration}.
 	 *
-	 * @return the annotated classes; potentially <code>null</code> or <em>empty</em>
+	 * @return the annotated classes; potentially {@code null} or <em>empty</em>
 	 * @see ContextConfiguration#classes
 	 * @see #setClasses(Class[])
 	 */
@@ -192,7 +228,7 @@ public void setClasses(Class<?>[] classes) {
 	 * Determine if this {@code ContextConfigurationAttributes} instance has
 	 * path-based resource locations.
 	 *
-	 * @return <code>true</code> if the {@link #getLocations() locations} array is not empty
+	 * @return {@code true} if the {@link #getLocations() locations} array is not empty
 	 * @see #hasResources()
 	 * @see #hasClasses()
 	 */
@@ -204,7 +240,7 @@ public boolean hasLocations() {
 	 * Determine if this {@code ContextConfigurationAttributes} instance has
 	 * class-based resources.
 	 *
-	 * @return <code>true</code> if the {@link #getClasses() classes} array is not empty
+	 * @return {@code true} if the {@link #getClasses() classes} array is not empty
 	 * @see #hasResources()
 	 * @see #hasLocations()
 	 */
@@ -216,7 +252,7 @@ public boolean hasClasses() {
 	 * Determine if this {@code ContextConfigurationAttributes} instance has
 	 * either path-based resource locations or class-based resources.
 	 *
-	 * @return <code>true</code> if either the {@link #getLocations() locations}
+	 * @return {@code true} if either the {@link #getLocations() locations}
 	 * or the {@link #getClasses() classes} array is not empty
 	 * @see #hasLocations()
 	 * @see #hasClasses()
@@ -226,21 +262,43 @@ public boolean hasResources() {
 	}
 
 	/**
-	 * Get the <code>inheritLocations</code> flag that was declared via
+	 * Get the {@code inheritLocations} flag that was declared via
 	 * {@link ContextConfiguration @ContextConfiguration}.
 	 *
-	 * @return the <code>inheritLocations</code> flag
+	 * @return the {@code inheritLocations} flag
 	 * @see ContextConfiguration#inheritLocations
 	 */
 	public boolean isInheritLocations() {
 		return inheritLocations;
 	}
 
 	/**
-	 * Get the <code>ContextLoader</code> class that was declared via
+	 * Get the {@code ApplicationContextInitializer} classes that were declared via
+	 * {@link ContextConfiguration @ContextConfiguration}.
+	 *
+	 * @return the {@code ApplicationContextInitializer} classes
+	 * @since 3.2
+	 */
+	public Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>[] getInitializers() {
+		return initializers;
+	}
+
+	/**
+	 * Get the {@code inheritInitializers} flag that was declared via
+	 * {@link ContextConfiguration @ContextConfiguration}.
+	 *
+	 * @return the {@code inheritInitializers} flag
+	 * @since 3.2
+	 */
+	public boolean isInheritInitializers() {
+		return inheritInitializers;
+	}
+
+	/**
+	 * Get the {@code ContextLoader} class that was declared via
 	 * {@link ContextConfiguration @ContextConfiguration}.
 	 *
-	 * @return the <code>ContextLoader</code> class
+	 * @return the {@code ContextLoader} class
 	 * @see ContextConfiguration#loader
 	 */
 	public Class<? extends ContextLoader> getContextLoaderClass() {
@@ -258,6 +316,8 @@ public String toString() {
 		.append("locations", ObjectUtils.nullSafeToString(locations))//
 		.append("classes", ObjectUtils.nullSafeToString(classes))//
 		.append("inheritLocations", inheritLocations)//
+		.append("initializers", ObjectUtils.nullSafeToString(initializers))//
+		.append("inheritInitializers", inheritInitializers)//
 		.append("contextLoaderClass", contextLoaderClass.getName())//
 		.toString();
 	}