Ensure TestExecutionListeners are loaded in native image

Prior to this commit, TestExecutionListener (TEL) implementations were
discovered via the `spring.factories` mechanism (via AOT
StaticSpringFactories), but they could not be loaded since the
necessary native image reflection configuration was missing.

This commit addresses this by introducing a
TestExecutionListenerFactoriesCodeContributor that only applies to
"org.springframework.test.context.TestExecutionListener" factory
entries. This FactoriesCodeContributor ensures that the fully qualified
class names for TELs can still be discovered via the
SpringFactoriesLoader, and it additionally registers reflection
configuration allowing the TELs to be instantiated reflectively.

In addition, this commit introduces a substitution for
AbstractTestContextBootstrapper.instantiateListeners() that serves as a
workaround for odd behavior in a GraalVM native image. Specifically, if
a NoClassDefFoundError is thrown during the native image build while
attempting to register a particular class for reflection, that class
will be magically "available" for loading via reflection within the
native image without throwing a NoClassDefFoundError (even though the
class cannot be loaded). As a result, an attempt to instantiate that
nonexistent class via reflection within the native image will result in
a NoSuchMethodException for the constructor. Since
AbstractTestContextBootstrapper.instantiateListeners() catches
NoClassDefFoundError in order to skip TestExecutionListeners that
cannot be loaded, within the native image our substitution has to also
catch NoSuchMethodException in order to skip such
TestExecutionListeners.

Closes gh-1217

Author: sbrannen

spring-aot/src/main/java/org/springframework/aot/factories/FactoriesCodeContributors.java

@@ -38,6 +38,7 @@ class FactoriesCodeContributors {
 
 	FactoriesCodeContributors(AotOptions aotOptions) {
 		this.contributors = Arrays.asList(new IgnoredFactoriesCodeContributor(),
+				new TestExecutionListenerFactoriesCodeContributor(),
 				new TestAutoConfigurationFactoriesCodeContributor(aotOptions),
 				new NoArgConstructorFactoriesCodeContributor(),
 				new PrivateFactoriesCodeContributor(),

spring-aot/src/main/java/org/springframework/aot/factories/TestExecutionListenerFactoriesCodeContributor.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019-2021 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.aot.factories;
+
+import com.squareup.javapoet.ClassName;
+
+import org.springframework.aot.build.context.BuildContext;
+import org.springframework.nativex.domain.reflect.ClassDescriptor;
+import org.springframework.nativex.hint.Flag;
+
+/**
+ * {@link FactoriesCodeContributor} that contributes source code for
+ * {@link org.springframework.test.context.TestExecutionListener} implementations.
+ * <p>Instead of instantiating them statically, we make sure that
+ * {@link org.springframework.core.io.support.SpringFactoriesLoader#loadFactoryNames(Class, ClassLoader)}
+ * will return their names and that reflection metadata is registered for native images.
+ *
+ * @author Sam Brannen
+ * @author Brian Clozel
+ * @see org.springframework.nativex.substitutions.framework.test.Target_AbstractTestContextBootstrapper
+ * @see org.springframework.test.context.support.AbstractTestContextBootstrapper.instantiateListeners
+ */
+class TestExecutionListenerFactoriesCodeContributor implements FactoriesCodeContributor {
+
+	@Override
+	public boolean canContribute(SpringFactory factory) {
+		return factory.getFactoryType().getClassName().equals("org.springframework.test.context.TestExecutionListener");
+	}
+
+	@Override
+	public void contribute(SpringFactory factory, CodeGenerator code, BuildContext context) {
+		ClassName factoryTypeClass = ClassName.bestGuess(factory.getFactoryType().getClassName());
+		generateReflectionMetadata(factory, context);
+		code.writeToStaticBlock(builder -> {
+			builder.addStatement("names.add($T.class, $S)", factoryTypeClass,
+					factory.getFactory().getClassName());
+		});
+	}
+
+	private void generateReflectionMetadata(SpringFactory factory, BuildContext context) {
+		String factoryClassName = factory.getFactory().getClassName();
+		ClassDescriptor factoryDescriptor = ClassDescriptor.of(factoryClassName);
+		factoryDescriptor.setFlag(Flag.allDeclaredConstructors);
+		context.describeReflection(reflect -> reflect.add(factoryDescriptor));
+	}
+
+}

spring-native/src/main/java/org/springframework/nativex/substitutions/framework/test/Target_AbstractTestContextBootstrapper.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2002-2020 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.nativex.substitutions.framework.test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import com.oracle.svm.core.annotate.Alias;
+import com.oracle.svm.core.annotate.Substitute;
+import com.oracle.svm.core.annotate.TargetClass;
+
+import org.apache.commons.logging.Log;
+
+import org.springframework.beans.BeanInstantiationException;
+import org.springframework.beans.BeanUtils;
+import org.springframework.nativex.substitutions.OnlyIfPresent;
+import org.springframework.test.context.TestExecutionListener;
+
+/**
+ * Native substitution for {@link org.springframework.test.context.support.AbstractTestContextBootstrapper}.
+ *
+ * <p>Necessary since class instantiation via reflection can result in a
+ * {@link NoSuchMethodException} instead of a {@link NoClassDefFoundError}
+ * within a native image, IF a {@link NoClassDefFoundError} was thrown during
+ * native image build time while attempting to register the class for reflection.
+ * In that case, the reflection registration still occurs, and we unfortunately
+ * see different behavior at runtime within the native image.
+ *
+ * <p>In summary, the only change this substitution makes is the following
+ * which additionally checks for a {@code NoSuchMethodException}:
+ * {@code if (cause instanceof NoClassDefFoundError || cause instanceof NoSuchMethodException)}.
+ *
+ * @author Sam Brannen
+ */
+@TargetClass(className = "org.springframework.test.context.support.AbstractTestContextBootstrapper", onlyWith = OnlyIfPresent.class)
+final class Target_AbstractTestContextBootstrapper {
+
+	@Alias
+	private Log logger;
+
+
+	@Substitute
+	private List<TestExecutionListener> instantiateListeners(Collection<Class<? extends TestExecutionListener>> classes) {
+		List<TestExecutionListener> listeners = new ArrayList<>(classes.size());
+		for (Class<? extends TestExecutionListener> listenerClass : classes) {
+			try {
+				listeners.add(BeanUtils.instantiateClass(listenerClass));
+			}
+			catch (BeanInstantiationException ex) {
+				Throwable cause = ex.getCause();
+				// Within a native image, NoSuchMethodException may be thrown instead of NoClassDefFoundError.
+				if (cause instanceof NoClassDefFoundError || cause instanceof NoSuchMethodException) {
+					// TestExecutionListener not applicable due to a missing dependency
+					if (logger.isDebugEnabled()) {
+						logger.debug(String.format(
+								"Skipping candidate TestExecutionListener [%s] due to a missing dependency. " +
+								"Specify custom listener classes or make the default listener classes " +
+								"and their required dependencies available. Offending class: [%s]",
+								listenerClass.getName(), cause.getMessage()));
+					}
+				}
+				else {
+					throw ex;
+				}
+			}
+		}
+		return listeners;
+	}
+
+}