add support for LifecycleMethodExecutionExceptionHandler (for spock's setupSpec, setup etc.)

Author: xvik

CHANGELOG.md

@@ -1,7 +1,8 @@
 * Update junit compatibility
     - [junit 5.11](https://docs.junit.org/5.11.0/release-notes/#release-notes-5.11.0-junit-jupiter-deprecations-and-breaking-changes): 
-      @ExtendWith on non-static field now participate in beforeAll/afterAll;
-      static extension fields are registered before non-static fields (fixed order)
+      * @ExtendWith on a non-static field now participate in beforeAll/afterAll;
+      * static extension fields are registered before non-static fields (junit behavior change)
+* Add support for LifecycleMethodExecutionExceptionHandler (for spock's setupSpec, setup etc.)
 
 ### 1.2.0 (2022-11-25)
 * Add root (engine-level) context to be able to use global storage in extensions (#44) 

src/main/java/ru/vyarus/spock/jupiter/engine/ExtensionUtils.java

@@ -81,7 +81,8 @@ public final class ExtensionUtils {
             ParameterResolver.class,
             TestInstancePostProcessor.class,
             TestInstancePreDestroyCallback.class,
-            TestExecutionExceptionHandler.class
+            TestExecutionExceptionHandler.class,
+            LifecycleMethodExecutionExceptionHandler.class
     );
 
     public static final List<Class<? extends Extension>> UNSUPPORTED_EXTENSIONS = Arrays.asList(
@@ -91,8 +92,6 @@ public final class ExtensionUtils {
             // impossible to add (spock does not allow this)
             TestInstanceFactory.class,
             TestInstancePreConstructCallback.class,
-            // could be supported, but what for?
-            LifecycleMethodExecutionExceptionHandler.class,
             InvocationInterceptor.class,
             // support could be added, but this is too specific (will never be required)
             TestWatcher.class

src/main/java/ru/vyarus/spock/jupiter/interceptor/ExtensionLifecycleMerger.java

@@ -62,7 +62,12 @@ public ExtensionLifecycleMerger(final ClassContext context) {
                 ctx = getMethodContext(invocation);
             }
             injectArguments(invocation, ctx);
-            invocation.proceed();
+            // intercepting here because the main interceptor does not receive exceptions (they are already eaten)
+            try {
+                invocation.proceed();
+            } catch (Throwable ex) {
+                handleFixtureMethodException(invocation, ctx, ex);
+            }
         };
     }
 
@@ -214,4 +219,25 @@ private void injectArguments(final IMethodInvocation invocation, final AbstractC
             }
         }
     }
+
+    private void handleFixtureMethodException(final IMethodInvocation invocation,
+                                              final AbstractContext context,
+                                              final Throwable throwable) {
+        switch (invocation.getMethod().getKind()) {
+            case SETUP_SPEC:
+                junit.handleSetupSpecMethodException(context, throwable);
+                break;
+            case SETUP:
+                junit.handleSetupMethodException(context, throwable);
+                break;
+            case CLEANUP:
+                junit.handleCleanupMethodException(context, throwable);
+                break;
+            case CLEANUP_SPEC:
+                junit.handleCleanupSpecMethodException(context, throwable);
+                break;
+            default:
+                throw new IllegalStateException("Unexpected method kind: " + invocation.getMethod().getKind());
+        }
+    }
 }

src/main/java/ru/vyarus/spock/jupiter/interceptor/JunitApiExecutor.java

@@ -7,6 +7,7 @@
 import org.junit.jupiter.api.extension.BeforeEachCallback;
 import org.junit.jupiter.api.extension.BeforeTestExecutionCallback;
 import org.junit.jupiter.api.extension.Extension;
+import org.junit.jupiter.api.extension.LifecycleMethodExecutionExceptionHandler;
 import org.junit.jupiter.api.extension.TestExecutionExceptionHandler;
 import org.junit.jupiter.api.extension.TestInstancePostProcessor;
 import org.junit.jupiter.api.extension.TestInstancePreDestroyCallback;
@@ -16,6 +17,7 @@
 import org.junit.platform.commons.util.ExceptionUtils;
 import org.junit.platform.commons.util.UnrecoverableExceptions;
 import org.junit.platform.engine.support.hierarchical.ThrowableCollector;
+import ru.vyarus.spock.jupiter.engine.ExtensionRegistry;
 import ru.vyarus.spock.jupiter.engine.context.AbstractContext;
 import ru.vyarus.spock.jupiter.engine.context.ClassContext;
 import ru.vyarus.spock.jupiter.engine.context.MethodContext;
@@ -71,11 +73,11 @@ public void beforeAll(final ClassContext context) {
     // org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.instantiateAndPostProcessTestInstance
     public void instancePostProcessors(final ClassContext context, final Object instance) {
         context.getCollector().execute(() -> {
-                getExtensions(context, TestInstancePostProcessor.class).forEach(
-                        extension -> executeAndMaskThrowable(() ->
-                                extension.postProcessTestInstance(instance, context)));
-                // init non-static field extensions
-                context.getRegistry().initializeExtensions(context.getRequiredTestClass(), instance);
+            getExtensions(context, TestInstancePostProcessor.class).forEach(
+                    extension -> executeAndMaskThrowable(() ->
+                            extension.postProcessTestInstance(instance, context)));
+            // init non-static field extensions
+            context.getRegistry().initializeExtensions(context.getRequiredTestClass(), instance);
         });
         context.getCollector().assertEmpty();
 
@@ -131,15 +133,43 @@ public void instancePreDestroy(final MethodContext context) {
 
     // org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.invokeAfterAllCallbacks
     public void afterAll(final ClassContext context) {
-        final ThrowableCollector collector = context.getCollector();
-        afterAllExtensions.forEach(
-                extension -> collector.execute(() -> extension.afterAll(context)));
-        collector.assertEmpty();
+        // null should be not possible, but just in case
+        if (afterAllExtensions != null) {
+            final ThrowableCollector collector = context.getCollector();
+            afterAllExtensions.forEach(
+                    extension -> collector.execute(() -> extension.afterAll(context)));
+            collector.assertEmpty();
+        }
+    }
+
+    public void handleTestException(final MethodContext context, final Throwable throwable) {
+        invokeExecutionExceptionHandlers(TestExecutionExceptionHandler.class, context.getRegistry(), throwable,
+                (handler, handledThrowable) -> handler
+                        .handleTestExecutionException(context, handledThrowable));
+    }
+
+    public void handleSetupSpecMethodException(final AbstractContext context, final Throwable throwable) {
+        invokeExecutionExceptionHandlers(LifecycleMethodExecutionExceptionHandler.class, context.getRegistry(),
+                throwable, (handler, handledThrowable) -> handler
+                        .handleBeforeAllMethodExecutionException(context, handledThrowable));
+    }
+
+    public void handleSetupMethodException(final AbstractContext context, final Throwable throwable) {
+        invokeExecutionExceptionHandlers(LifecycleMethodExecutionExceptionHandler.class, context.getRegistry(),
+                throwable, (handler, handledThrowable) -> handler
+                        .handleBeforeEachMethodExecutionException(context, handledThrowable));
+    }
+
+    public void handleCleanupMethodException(final AbstractContext context, final Throwable throwable) {
+        invokeExecutionExceptionHandlers(LifecycleMethodExecutionExceptionHandler.class, context.getRegistry(),
+                throwable, (handler, handledThrowable) -> handler
+                        .handleAfterEachMethodExecutionException(context, handledThrowable));
     }
 
-    // org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.invokeTestExecutionExceptionHandlers
-    public void handleTestException(final MethodContext context, final Throwable error) {
-        processTestException(context, getReversedExtensions(context, TestExecutionExceptionHandler.class), error);
+    public void handleCleanupSpecMethodException(final AbstractContext context, final Throwable throwable) {
+        invokeExecutionExceptionHandlers(LifecycleMethodExecutionExceptionHandler.class, context.getRegistry(),
+                throwable, (handler, handledThrowable) -> handler
+                        .handleAfterAllMethodExecutionException(context, handledThrowable));
     }
 
     private <T extends Extension> List<T> getReversedExtensions(final AbstractContext context, final Class<T> type) {
@@ -165,29 +195,56 @@ private <T extends Extension> List<T> getExtensions(final AbstractContext contex
         return exts;
     }
 
-    private void executeAndMaskThrowable(final Executable executable) {
-        try {
-            executable.execute();
-        } catch (Throwable throwable) {
-            ExceptionUtils.throwAsUncheckedException(throwable);
-        }
+    /**
+     * Invoke exception handlers for the supplied {@code Throwable} one-by-one
+     * until none are left or the throwable to handle has been swallowed.
+     */
+    // org.junit.jupiter.engine.descriptor.JupiterTestDescriptor.invokeExecutionExceptionHandlers
+    private <E extends Extension> void invokeExecutionExceptionHandlers(
+            final Class<E> handlerType,
+            final ExtensionRegistry registry,
+            final Throwable throwable,
+            final ExceptionHandlerInvoker<E> handlerInvoker) {
+
+        final List<E> extensions = registry.getReversedExtensions(handlerType);
+        invokeExecutionExceptionHandlers(extensions, throwable, handlerInvoker);
     }
 
     // org.junit.jupiter.engine.descriptor.JupiterTestDescriptor.invokeExecutionExceptionHandlers
-    private void processTestException(final MethodContext context,
-                                      final List<TestExecutionExceptionHandler> handlers,
-                                      final Throwable error) {
+    private <E extends Extension> void invokeExecutionExceptionHandlers(
+            final List<E> exceptionHandlers,
+            final Throwable throwable,
+            final ExceptionHandlerInvoker<E> handlerInvoker) {
+
         // No handlers left?
-        if (handlers.isEmpty()) {
-            ExceptionUtils.throwAsUncheckedException(error);
+        if (exceptionHandlers.isEmpty()) {
+            throw ExceptionUtils.throwAsUncheckedException(throwable);
         }
 
         try {
             // Invoke next available handler
-            handlers.remove(0).handleTestExecutionException(context, error);
+            handlerInvoker.invoke(exceptionHandlers.remove(0), throwable);
         } catch (Throwable handledThrowable) {
             UnrecoverableExceptions.rethrowIfUnrecoverable(handledThrowable);
-            processTestException(context, handlers, handledThrowable);
+            invokeExecutionExceptionHandlers(exceptionHandlers, handledThrowable, handlerInvoker);
         }
     }
+
+    private void executeAndMaskThrowable(final Executable executable) {
+        try {
+            executable.execute();
+        } catch (Throwable throwable) {
+            ExceptionUtils.throwAsUncheckedException(throwable);
+        }
+    }
+
+    @FunctionalInterface
+    interface ExceptionHandlerInvoker<E extends Extension> {
+
+        /**
+         * Invoke the supplied {@code exceptionHandler} with the supplied {@code throwable}.
+         */
+        void invoke(E exceptionHandler, Throwable throwable) throws Throwable;
+
+    }
 }

src/test/groovy/ru/vyarus/spock/jupiter/SpockErrorsTest.groovy

@@ -13,6 +13,7 @@ import playground.tests.exceptions.JupiterPreDestroyError
 import playground.tests.exceptions.JupiterTestError
 import playground.tests.exceptions.JupiterTestExceptionHandler
 import playground.tests.exceptions.JupiterTestExceptionHandler2
+import playground.tests.exceptions.JupiterTestExceptionHandler3
 import ru.vyarus.spock.jupiter.test.exception.*
 
 /**
@@ -211,7 +212,7 @@ class SpockErrorsTest extends AbstractTest {
                     "BeforeEachCallback",
                     "BeforeTestExecutionCallback",
                     "RethrowExceptionHandler problem",
-                    "SwallowExceptionHandler problem",
+                    "EatExceptionHandler problem",
                     "AfterTestExecutionCallback",
                     "AfterEachCallback",
                     "AfterAllCallback"]
@@ -220,17 +221,35 @@ class SpockErrorsTest extends AbstractTest {
     def "Check exception handler on assertion"() {
 
         expect: 'assertion swallowed'
-        runTest(JupiterTestExceptionHandler2, SpockTestExceptionHandler2)
+        runTestWithVerification(JupiterTestExceptionHandler2, SpockTestExceptionHandler2,
+                "assert fail", "Condition not satisfied:\n\nfalse\n")
+                
                 == ["BeforeAllCallback",
                     "BeforeEachCallback",
                     "BeforeTestExecutionCallback",
                     "RethrowExceptionHandler Condition not satisfied:\n\nfalse\n",
-                    "SwallowExceptionHandler Condition not satisfied:\n\nfalse\n",
+                    "EatExceptionHandler Condition not satisfied:\n\nfalse\n",
                     "AfterTestExecutionCallback",
                     "AfterEachCallback",
                     "AfterAllCallback"]
     }
 
+    def "Check exception handler rethrows"() {
+
+        expect: 'assertion swallowed'
+        runTestWithVerification(JupiterTestExceptionHandler3, SpockTestExceptionHandler3,
+                "assert fail", "Condition not satisfied:\n\nfalse\n",
+                "AssertionFailedError", "ConditionNotSatisfiedError")
+                == ["BeforeAllCallback",
+                    "BeforeEachCallback",
+                    "BeforeTestExecutionCallback",
+                    "RethrowExceptionHandler Condition not satisfied:\n\nfalse\n",
+                    "AfterTestExecutionCallback",
+                    "AfterEachCallback",
+                    "AfterAllCallback",
+                    "Error: (ConditionNotSatisfiedError) Condition not satisfied:\n\nfalse\n"]
+    }
+
     def "Check executable invoker error"() {
 
         expect: 'executable invoker call failed'
@@ -240,7 +259,7 @@ class SpockErrorsTest extends AbstractTest {
     def "Check no supported extension found"() {
 
         expect: 'error'
-        runTest(SpockNotSupportedExtensions) == ["Error: (IllegalStateException) Extension ru.vyarus.spock.jupiter.test.exception.SpockNotSupportedExtensions\$NotSupportedExtension does not use any of supported extension types: ExecutionCondition, BeforeAllCallback, AfterAllCallback, BeforeEachCallback, AfterEachCallback, BeforeTestExecutionCallback, AfterTestExecutionCallback, ParameterResolver, TestInstancePostProcessor, TestInstancePreDestroyCallback, TestExecutionExceptionHandler"]
+        runTest(SpockNotSupportedExtensions) == ["Error: (IllegalStateException) Extension ru.vyarus.spock.jupiter.test.exception.SpockNotSupportedExtensions\$NotSupportedExtension does not use any of supported extension types: ExecutionCondition, BeforeAllCallback, AfterAllCallback, BeforeEachCallback, AfterEachCallback, BeforeTestExecutionCallback, AfterTestExecutionCallback, ParameterResolver, TestInstancePostProcessor, TestInstancePreDestroyCallback, TestExecutionExceptionHandler, LifecycleMethodExecutionExceptionHandler"]
     }
 
     def "Check extension with both supported and not supported extensions"() {