Rename AotContextLoader to AotTestMappings and update Javadoc

sbrannen · sbrannen · commit d9d03dbe0d33 · 2021-12-07T16:49:11.000+01:00
See gh-1262
diff --git a/spring-native/src/main/java/org/springframework/aot/test/AotCacheAwareContextLoaderDelegate.java b/spring-native/src/main/java/org/springframework/aot/test/AotCacheAwareContextLoaderDelegate.java
@@ -40,20 +40,20 @@ public class AotCacheAwareContextLoaderDelegate extends DefaultCacheAwareContext
 
 	private static final Log logger = LogFactory.getLog(AotCacheAwareContextLoaderDelegate.class);
 
-	private final AotContextLoader aotContextLoader;
+	private final AotTestMappings aotTestMappings;
 
 	public AotCacheAwareContextLoaderDelegate() {
-		this.aotContextLoader = new AotContextLoader();
+		this.aotTestMappings = new AotTestMappings();
 	}
 
-	AotCacheAwareContextLoaderDelegate(AotContextLoader aotContextLoader, ContextCache contextCache) {
+	AotCacheAwareContextLoaderDelegate(AotTestMappings aotTestMappings, ContextCache contextCache) {
 		super(contextCache);
-		this.aotContextLoader = aotContextLoader;
+		this.aotTestMappings = aotTestMappings;
 	}
 
 	@Override
 	protected ApplicationContext loadContextInternal(MergedContextConfiguration config) throws Exception {
-		SmartContextLoader contextLoader = this.aotContextLoader.getContextLoader(config.getTestClass());
+		SmartContextLoader contextLoader = this.aotTestMappings.getContextLoader(config.getTestClass());
 		if (contextLoader != null) {
 			Assert.isInstanceOf(AotMergedContextConfiguration.class, config);
 			logger.info("Loading test ApplicationContext in AOT mode using " + contextLoader);
@@ -94,7 +94,7 @@ private MergedContextConfiguration replaceIfNecessary(MergedContextConfiguration
 
 		Class<?> testClass = mergedContextConfiguration.getTestClass();
 		Class<? extends ApplicationContextInitializer<?>> contextInitializerClass =
-				this.aotContextLoader.getContextInitializerClass(testClass);
+				this.aotTestMappings.getContextInitializerClass(testClass);
 
 		if (contextInitializerClass != null) {
 			return new AotMergedContextConfiguration(testClass, contextInitializerClass, mergedContextConfiguration,
diff --git a/spring-native/src/main/java/org/springframework/aot/test/AotDependencyInjectionTestExecutionListener.java b/spring-native/src/main/java/org/springframework/aot/test/AotDependencyInjectionTestExecutionListener.java
@@ -39,14 +39,14 @@
  *
  * @author Sam Brannen
  * @see DependencyInjectionTestExecutionListener
- * @see AotContextLoader
+ * @see AotTestMappings
  * @see AotCacheAwareContextLoaderDelegate
  */
 public class AotDependencyInjectionTestExecutionListener extends DependencyInjectionTestExecutionListener {
 
 	private static final Log logger = LogFactory.getLog(AotDependencyInjectionTestExecutionListener.class);
 
-	private static final AotContextLoader aotContextLoader = getAotContextLoader();
+	private static final AotTestMappings aotTestMappings = getAotTestMappings();
 
 
 	@Override
@@ -96,16 +96,16 @@ private void injectDependenciesInAotMode(TestContext testContext) throws Excepti
 	}
 
 	private boolean isSupportedTestClass(TestContext testContext) {
-		return aotContextLoader != null && aotContextLoader.isSupportedTestClass(testContext.getTestClass());
+		return aotTestMappings != null && aotTestMappings.isSupportedTestClass(testContext.getTestClass());
 	}
 
-	private static AotContextLoader getAotContextLoader() {
+	private static AotTestMappings getAotTestMappings() {
 		if (AotModeDetector.isRunningAotTests()) {
 			try {
-				return new AotContextLoader();
+				return new AotTestMappings();
 			}
 			catch (Exception ex) {
-				throw new IllegalStateException("Failed to instantiate AotContextLoader", ex);
+				throw new IllegalStateException("Failed to instantiate AotTestMappings", ex);
 			}
 		}
 		return null;
diff --git a/spring-native/src/main/java/org/springframework/aot/test/AotTestMappings.java b/spring-native/src/main/java/org/springframework/aot/test/AotTestMappings.java
@@ -26,40 +26,77 @@
 import org.springframework.util.ReflectionUtils;
 
 /**
- * Load generated application contexts for supported test classes.
+ * {@code AotTestMappings} provides mappings from test classes to AOT context loaders
+ * and context initializers.
+ * <p/>
+ * If a test class is not {@linkplain #isSupportedTestClass(Class) supported} in
+ * AOT mode, {@link #getContextLoader(Class)} and {@link #getContextInitializerClass(Class)}
+ * will return {@code null}.
  * <p/>
  * Reflectively accesses {@value #INITIALIZER_NAME} generated by the
- * {@code TestContextAotProcessor} in the {@code spring-aot-test} module to retrieve the
- * mapping of all supported test classes.
+ * {@code TestContextAotProcessor} in the {@code spring-aot-test} module to retrieve
+ * the mappings.
  *
  * @author Stephane Nicoll
  * @author Sam Brannen
  */
-class AotContextLoader {
+class AotTestMappings {
 
 	private static final String INITIALIZER_NAME = "org.springframework.aot.TestContextBootstrapInitializer";
 
+
 	private final Map<String, Supplier<SmartContextLoader>> contextLoaders;
 
 	private final Map<String, Class<? extends ApplicationContextInitializer<?>>> contextInitializers;
 
 
-	AotContextLoader(Map<String, Supplier<SmartContextLoader>> contextLoaders,
+	AotTestMappings(Map<String, Supplier<SmartContextLoader>> contextLoaders,
 			Map<String, Class<? extends ApplicationContextInitializer<?>>> contextInitializers) {
 
 		this.contextLoaders = contextLoaders;
 		this.contextInitializers = contextInitializers;
 	}
 
 	@SuppressWarnings("unchecked")
-	AotContextLoader(String initializerClassName) {
+	AotTestMappings(String initializerClassName) {
 		this(loadMap(initializerClassName, "getContextLoaders"), loadMap(initializerClassName, "getContextInitializers"));
 	}
 
-	AotContextLoader() {
+	AotTestMappings() {
 		this(INITIALIZER_NAME);
 	}
 
+	/**
+	 * Determine if the specified test class has an AOT-generated application context.
+	 * <p>If this method returns {@code true}, {@link #getContextLoader(Class)} and
+	 * {@link #getContextInitializerClass(Class)} should return non-null values.
+	 */
+	boolean isSupportedTestClass(Class<?> testClass) {
+		return this.contextLoaders.containsKey(testClass.getName());
+	}
+
+	/**
+	 * Get the AOT {@link SmartContextLoader} for the specified test class.
+	 * @return the AOT context loader, or {@code null} if there is no AOT context
+	 * loader for the specified test class
+	 * @see #isSupportedTestClass(Class)
+	 */
+	SmartContextLoader getContextLoader(Class<?> testClass) {
+		Supplier<SmartContextLoader> supplier = this.contextLoaders.get(testClass.getName());
+		return (supplier != null) ? supplier.get() : null;
+	}
+
+	/**
+	 * Get the AOT {@link ApplicationContextInitializer} for the specified test class.
+	 * @return the AOT context initializer, or {@code null} if there is no AOT context
+	 * initializer for the specified test class
+	 * @see #isSupportedTestClass(Class)
+	 */
+	Class<? extends ApplicationContextInitializer<?>> getContextInitializerClass(Class<?> testClass) {
+		return this.contextInitializers.get(testClass.getName());
+	}
+
+
 	@SuppressWarnings("rawtypes")
 	private static Map loadMap(String className, String methodName) {
 		try {
@@ -78,17 +115,4 @@ private static Map loadMap(String className, String methodName) {
 		}
 	}
 
-	SmartContextLoader getContextLoader(Class<?> testClass) {
-		Supplier<SmartContextLoader> supplier = this.contextLoaders.get(testClass.getName());
-		return (supplier != null) ? supplier.get() : null;
-	}
-
-	boolean isSupportedTestClass(Class<?> testClass) {
-		return this.contextLoaders.containsKey(testClass.getName());
-	}
-
-	Class<? extends ApplicationContextInitializer<?>> getContextInitializerClass(Class<?> testClass) {
-		return this.contextInitializers.get(testClass.getName());
-	}
-
 }
diff --git a/spring-native/src/test/java/org/springframework/aot/test/AotCacheAwareContextLoaderDelegateTests.java b/spring-native/src/test/java/org/springframework/aot/test/AotCacheAwareContextLoaderDelegateTests.java
@@ -20,8 +20,8 @@
 import java.util.function.Supplier;
 
 import org.junit.jupiter.api.Test;
-
 import org.mockito.ArgumentCaptor;
+
 import org.springframework.boot.SpringBootConfiguration;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.context.SpringBootTestContextBootstrapper;
@@ -143,8 +143,8 @@ private AotCacheAwareContextLoaderDelegate createDemoDelegate() {
 	private AotCacheAwareContextLoaderDelegate createAotCacheAwareContextLoaderDelegate(
 			Map<String, Supplier<SmartContextLoader>> contextLoaders,
 			Map<String, Class<? extends ApplicationContextInitializer<?>>> contextInitializers) {
-		AotContextLoader aotContextLoader = new AotContextLoader(contextLoaders, contextInitializers);
-		return new AotCacheAwareContextLoaderDelegate(aotContextLoader, this.contextCache);
+		AotTestMappings aotTestMappings = new AotTestMappings(contextLoaders, contextInitializers);
+		return new AotCacheAwareContextLoaderDelegate(aotTestMappings, this.contextCache);
 	}
 
 	private void verifyCached(Class<? extends MergedContextConfiguration> type) {
diff --git a/spring-native/src/test/java/org/springframework/aot/test/AotTestMappingsTests.java b/spring-native/src/test/java/org/springframework/aot/test/AotTestMappingsTests.java
@@ -32,56 +32,56 @@
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 
 /**
- * Tests for {@link AotContextLoader}.
+ * Tests for {@link AotTestMappings}.
  *
  * @author Stephane Nicoll
  * @author Sam Brannen
  */
-class AotContextLoaderTests {
+class AotTestMappingsTests {
 
 	@Test
 	void loadWithClassNameFindsMatchingContextLoader() {
-		AotContextLoader aotContextLoader = new AotContextLoader(TestMapping.class.getName());
-		assertThat(aotContextLoader.getContextLoader(AotContextLoaderTests.class))
+		AotTestMappings aotTestMappings = new AotTestMappings(TestMapping.class.getName());
+		assertThat(aotTestMappings.getContextLoader(AotTestMappingsTests.class))
 				.isInstanceOf(AotSpringBootConfigContextLoader.class);
 	}
 
 	@Test
 	void loadWithClassNameReturnsNullContextLoaderForUnregisteredTest() {
-		AotContextLoader aotContextLoader = new AotContextLoader(TestMapping.class.getName());
-		assertThat(aotContextLoader.getContextLoader(Map.class)).isNull();
+		AotTestMappings aotTestMappings = new AotTestMappings(TestMapping.class.getName());
+		assertThat(aotTestMappings.getContextLoader(Map.class)).isNull();
 	}
 
 	@Test
 	void loadWithClassNameFindsMatchingContextInitializerClass() {
-		AotContextLoader aotContextLoader = new AotContextLoader(TestMapping.class.getName());
-		assertThat(aotContextLoader.getContextInitializerClass(AotContextLoaderTests.class))
+		AotTestMappings aotTestMappings = new AotTestMappings(TestMapping.class.getName());
+		assertThat(aotTestMappings.getContextInitializerClass(AotTestMappingsTests.class))
 				.isEqualTo(TestApplicationContextInitializer.class);
 	}
 
 	@Test
 	void loadWithClassNameReturnsNullContextInitializerClassForUnregisteredTest() {
-		AotContextLoader aotContextLoader = new AotContextLoader(TestMapping.class.getName());
-		assertThat(aotContextLoader.getContextInitializerClass(Map.class)).isNull();
+		AotTestMappings aotTestMappings = new AotTestMappings(TestMapping.class.getName());
+		assertThat(aotTestMappings.getContextInitializerClass(Map.class)).isNull();
 	}
 
 	@Test
 	void loadWithClassNameWithoutContextLoadersMethod() {
-		assertThatIllegalStateException().isThrownBy(() -> new AotContextLoader(Map.class.getName()))
+		assertThatIllegalStateException().isThrownBy(() -> new AotTestMappings(Map.class.getName()))
 				.withMessage("No getContextLoaders() method found on java.util.Map");
 	}
 
 	@Test
 	void loadWithClassNameWithoutContextInitializersMethod() {
 		String className = HalfBakedTestMapping.class.getName();
-		assertThatIllegalStateException().isThrownBy(() -> new AotContextLoader(className))
+		assertThatIllegalStateException().isThrownBy(() -> new AotTestMappings(className))
 				.withMessage("No getContextInitializers() method found on " + className);
 	}
 
 	@Test
 	void loadWithClassNameThatDoesNotExist() {
 		String className = "com.example.DoesNotExist";
-		assertThatIllegalStateException().isThrownBy(() -> new AotContextLoader(className))
+		assertThatIllegalStateException().isThrownBy(() -> new AotTestMappings(className))
 				.withMessageMatching("Failed to load .+ method in " + Pattern.quote(className))
 				.withCauseInstanceOf(ClassNotFoundException.class);
 	}
@@ -91,14 +91,14 @@ public static class TestMapping {
 
 		public static Map<String, Supplier<SmartContextLoader>> getContextLoaders() {
 			Map<String, Supplier<SmartContextLoader>> entries = new HashMap<>();
-			entries.put(AotContextLoaderTests.class.getName(), () -> new AotSpringBootConfigContextLoader(TestApplicationContextInitializer.class));
+			entries.put(AotTestMappingsTests.class.getName(), () -> new AotSpringBootConfigContextLoader(TestApplicationContextInitializer.class));
 			entries.put("com.example.SampleTests", () -> new AotSpringBootConfigContextLoader(TestApplicationContextInitializer.class));
 			return entries;
 		}
 
 		public static Map<String, Class<? extends ApplicationContextInitializer<?>>> getContextInitializers() {
 			Map<String, Class<? extends ApplicationContextInitializer<?>>> map = new HashMap<>();
-			map.put(AotContextLoaderTests.class.getName(), TestApplicationContextInitializer.class);
+			map.put(AotTestMappingsTests.class.getName(), TestApplicationContextInitializer.class);
 			map.put("com.example.SampleTests", TestApplicationContextInitializer.class);
 			return map;
 		}

Original file line number	Diff line number	Diff line change
`@@ -39,14 +39,14 @@`
`39`	`39`	`*`
`40`	`40`	`* @author Sam Brannen`
`41`	`41`	`* @see DependencyInjectionTestExecutionListener`
`42`		`- * @see AotContextLoader`
	`42`	`+ * @see AotTestMappings`
`43`	`43`	`* @see AotCacheAwareContextLoaderDelegate`
`44`	`44`	`*/`
`45`	`45`	`public class AotDependencyInjectionTestExecutionListener extends DependencyInjectionTestExecutionListener {`
`46`	`46`
`47`	`47`	`private static final Log logger = LogFactory.getLog(AotDependencyInjectionTestExecutionListener.class);`
`48`	`48`
`49`		`- private static final AotContextLoader aotContextLoader = getAotContextLoader();`
	`49`	`+ private static final AotTestMappings aotTestMappings = getAotTestMappings();`
`50`	`50`
`51`	`51`
`52`	`52`	`@Override`
`@@ -96,16 +96,16 @@ private void injectDependenciesInAotMode(TestContext testContext) throws Excepti`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`private boolean isSupportedTestClass(TestContext testContext) {`
`99`		`- return aotContextLoader != null && aotContextLoader.isSupportedTestClass(testContext.getTestClass());`
	`99`	`+ return aotTestMappings != null && aotTestMappings.isSupportedTestClass(testContext.getTestClass());`
`100`	`100`	`}`
`101`	`101`
`102`		`- private static AotContextLoader getAotContextLoader() {`
	`102`	`+ private static AotTestMappings getAotTestMappings() {`
`103`	`103`	`if (AotModeDetector.isRunningAotTests()) {`
`104`	`104`	`try {`
`105`		`- return new AotContextLoader();`
	`105`	`+ return new AotTestMappings();`
`106`	`106`	`}`
`107`	`107`	`catch (Exception ex) {`
`108`		`- throw new IllegalStateException("Failed to instantiate AotContextLoader", ex);`
	`108`	`+ throw new IllegalStateException("Failed to instantiate AotTestMappings", ex);`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`	`return null;`