How to access ExecutableInvoker with the current ExtensionRegistry?

[alanwong-toast]

I was hoping that ExecutableInvoker (accessible from ExtensionContext) would allow for the invocation of methods/classes with the currently known set of ParameterResolvers, but based on my testing, it seems that it only loads with a default set of resolvers and never the resolvers I have injected.

The creation of the DefaultExecutableInvoker happens here:

junit5/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassBasedTestDescriptor.java

Lines 149 to 151 in ae20d63

	public JupiterEngineExecutionContext prepare(JupiterEngineExecutionContext context) {
	MutableExtensionRegistry registry = populateNewExtensionRegistryFromExtendWithAnnotation(
	context.getExtensionRegistry(), this.testClass);

junit5/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassBasedTestDescriptor.java

Lines 179 to 192 in ae20d63

	ThrowableCollector throwableCollector = createThrowableCollector();
	ExecutableInvoker executableInvoker = new DefaultExecutableInvoker(context);
	ClassExtensionContext extensionContext = new ClassExtensionContext(context.getExtensionContext(),
	context.getExecutionListener(), this, this.lifecycle, context.getConfiguration(), throwableCollector,
	executableInvoker);
	// @formatter:off
	return context.extend()
	.withTestInstancesProvider(testInstancesProvider(context, extensionContext))
	.withExtensionRegistry(registry)
	.withExtensionContext(extensionContext)
	.withThrowableCollector(throwableCollector)
	.build();
	// @formatter:on

With this constructor for DefaultExecutableInvoker:

junit5/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/execution/DefaultExecutableInvoker.java

Lines 40 to 42 in ae20d63

	public DefaultExecutableInvoker(JupiterEngineExecutionContext context) {
	this(context.getExtensionContext(), context.getExtensionRegistry());
	}

It appears that the new extension registry generated from populateNewExtensionRegistryFromExtendWithAnnotation at the top is never passed into the new context that is used to construct the class's context.

This results in a default set of resolvers in all cases, regardless of which extension interface I use to get the extension context.

Is there a correct way to utilize ExecutableInvoker such that the context of the currently running test has access to that test's ParameterResolvers?

[marcphilipp]

This works expected:

import static org.junit.jupiter.api.Assertions.assertEquals;

import java.lang.reflect.Method;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.extension.Extension;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ParameterContext;
import org.junit.jupiter.api.extension.ParameterResolutionException;
import org.junit.jupiter.api.extension.ParameterResolver;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.platform.commons.support.ReflectionSupport;

@ExtendWith(ExecutableInvokerDemo.LongParameterResolver.class)
public class ExecutableInvokerDemo {

	@RegisterExtension
	Extension indirectResolver = new IndirectParameterResolver(ReflectionSupport.findMethod(getClass(), "method", long.class));

	@Test
	void test(AtomicLong value) {
		assertEquals(42, value.get());
	}

	AtomicLong method(long value) {
		return new AtomicLong(value);
	}

	static class LongParameterResolver implements ParameterResolver {

		@Override
		public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
			return long.class.equals(parameterContext.getParameter().getType());
		}

		@Override
		public Long resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
			return 42L;
		}
	}

	static class IndirectParameterResolver implements ParameterResolver {

		private final Method method;

		public IndirectParameterResolver(Optional<Method> method) {
			this.method = method.orElseThrow(() -> new ParameterResolutionException("Failed to find method"));
		}

		@Override
		public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
			return method.getReturnType().equals(parameterContext.getParameter().getType());
		}

		@Override
		public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
			return extensionContext.getExecutableInvoker().invoke(method, extensionContext.getRequiredTestInstance());
		}
	}
}

Please post a concrete example of what doesn't work for you.

[alanwong-toast]

Here is what I'm seeing:

@ExtendWith(ExecutableInvokerDemo2.LongParameterResolver::class)
@ExtendWith(ExecutableInvokerDemo2.IndirectParameterResolver::class)
class ExecutableInvokerDemo2(
    // private val constructorValue: AtomicLong
) {
    @Test
    fun test(methodValue: AtomicLong) {
        // This method injection works as expected.
        assertEquals(42L, methodValue.get())

        // If this constructor injection assertion is uncommented (along with the associated constructor
        // parameter), this test fails.
        // assertEquals(42L, constructorValue.get())
    }

    internal class LongParameterResolver : ParameterResolver {
        override fun supportsParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Boolean =
            Long::class.javaPrimitiveType == parameterContext.parameter.type

        override fun resolveParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Long = 42L
    }

    internal class IndirectParameterResolver : ParameterResolver {
        private val method: Method = ReflectionSupport
            .findMethod(IndirectParameterResolver::class.java, "method", Long::class.javaPrimitiveType)
            .orElseThrow { ParameterResolutionException("Failed to find method") }

        fun method(value: Long): AtomicLong {
            return AtomicLong(value)
        }

        // While debugging, `extensionContext.executableInvoker.extensionRegistry` shows the correct
        // set of extensions only when injecting at the method level. If the constructor level property
        // is uncommented, the registry shows the default extensions when it attempts to inject at the
        // constructor level.
        // 
        // Example with method injection:
        //     0 = {ExecutableInvokerDemo2$LongParameterResolver@3057} 
        //     1 = {ExecutableInvokerDemo2$IndirectParameterResolver@2825} 
        // 
        // Example with constructor injection:
        //     0 = {DisabledCondition@3035} 
        //     1 = {TimeoutExtension@3036} 
        //     2 = {RepeatedTestExtension@3037} 
        //     3 = {TestInfoParameterResolver@3038} 
        //     4 = {TestReporterParameterResolver@3039} 
        //     5 = {TempDirectory@3040}
        override fun supportsParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Boolean =
            method.returnType.equals(parameterContext.parameter.getType());

        override fun resolveParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Any =
            extensionContext.executableInvoker.invoke(method, this)
    }
}

[marcphilipp]

That does indeed look like a bug. I'll investigate.

[marcphilipp]

Will be fixed in #3905.

[alanwong-toast]

Thanks!

[marcphilipp]

5.11.0-RC1 was released today and includes a fix.