Retry extension does not mesh with TestAbortedException and PendingFeature

The Retry annotation now skips when a TestAbortedException is thrown.
And it also interoperates now with the PendingFeature correctly.

Fixes #1863

Author: AndreasTu

docs/release_notes.adoc

@@ -62,6 +62,7 @@ will now require that the spec is annotated with <<parallel_execution.adoc#isola
 * Fix incompatibility with JUnit 6 in OSGi environment spockIssue:2231[]
 * OSGi: Pin the `Require-Capability:osgi.ee=JavaSE` to Java `8` spockPull:2233[]
 * Fix: Prevent NPE in SpecRunHistory.sortFeatures when duration is missing spockIssue:2234[]
+* Retry extension does not mesh with TestAbortedException and PendingFeature spockIssue:1863[]
 
 == 2.4-M6 (2025-04-15)
 

spock-core/src/main/java/org/spockframework/runtime/extension/builtin/RetryBaseInterceptor.java

@@ -16,6 +16,7 @@
 
 package org.spockframework.runtime.extension.builtin;
 
+import org.opentest4j.TestAbortedException;
 import org.spockframework.runtime.GroovyRuntimeUtil;
 import org.spockframework.runtime.extension.*;
 import spock.lang.Retry;
@@ -58,6 +59,12 @@ protected boolean isExpected(IMethodInvocation invocation, Throwable failure) {
   }
 
   private boolean hasExpectedClass(Throwable failure) {
+    for (Class<? extends Throwable> exception : retry.skipRetryExceptions()) {
+      if (exception.isInstance(failure)) {
+        return false;
+      }
+    }
+
     for (Class<? extends Throwable> exception : retry.exceptions()) {
       if (exception.isInstance(failure)) {
         return true;

spock-core/src/main/java/org/spockframework/runtime/extension/builtin/RetryIterationInterceptor.java

@@ -39,7 +39,23 @@ public class RetryIterationInterceptor extends RetryBaseInterceptor implements I
 
   public RetryIterationInterceptor(Retry retry, MethodInfo featureMethod) {
     super(retry);
-    featureMethod.addInterceptor(new InnerRetryInterceptor(retry, condition));
+    InnerRetryInterceptor interceptor = new InnerRetryInterceptor(retry, condition);
+    addInterceptorToFeatureMethod(featureMethod, interceptor);
+  }
+
+  private static void addInterceptorToFeatureMethod(MethodInfo featureMethod, InnerRetryInterceptor interceptor) {
+    List<IMethodInterceptor> interceptors = featureMethod.getInterceptors();
+    for (int i = 0; i < interceptors.size(); i++) {
+      IMethodInterceptor existing = interceptors.get(i);
+      if (existing instanceof PendingFeatureInterceptor) {
+        //Make sure we insert the RetryInterceptor before the PendingFeatureInterceptor
+        //otherwise the PendingFeatureInterceptor will fail, because the RetryInterceptor swallowed the exceptions.
+        //This would lead to a PendingFeatureSuccessfulError
+        interceptors.add(i, interceptor);
+        return;
+      }
+    }
+    interceptors.add(interceptor);
   }
 
   @Override
@@ -59,7 +75,7 @@ public void intercept(IMethodInvocation invocation) throws Throwable {
 
   private class InnerRetryInterceptor extends RetryBaseInterceptor implements IMethodInterceptor {
 
-    public InnerRetryInterceptor(Retry retry, Closure condition) {
+    public InnerRetryInterceptor(Retry retry, Closure<?> condition) {
       super(retry, condition);
     }
 

spock-core/src/main/java/spock/lang/Retry.java

@@ -16,7 +16,9 @@
 
 package spock.lang;
 
+import org.opentest4j.TestAbortedException;
 import org.spockframework.runtime.extension.ExtensionAnnotation;
+import org.spockframework.runtime.extension.builtin.PendingFeatureSuccessfulError;
 import org.spockframework.runtime.extension.builtin.RetryExtension;
 import org.spockframework.util.Beta;
 
@@ -54,6 +56,23 @@
    */
   Class<? extends Throwable>[] exceptions() default {Exception.class, AssertionError.class};
 
+  /**
+   * Configures which types of Exceptions should skip any remaining retry.
+   * If the retry is skipped, the exception will be thrown.
+   *
+   * <p>Subclasses are included if their parent class is listed.
+   *
+   * <p>These Exceptions are evaluated before {@link #exceptions()} are evaluated.
+   *
+   * @return array of Exception classes which cause the retry to skip.
+   * @since 2.4
+   */
+  @Beta
+  Class<? extends Throwable>[] skipRetryExceptions() default {
+    TestAbortedException.class, //TestAbortedException shall skip to allow interop with annotations like @IgnoreIf, see #1863
+    PendingFeatureSuccessfulError.class //Iterop with @PendingFeature to skip the Retry
+  };
+
   /**
    * Condition that is evaluated to decide whether the feature should be
    * retried.
@@ -99,7 +118,7 @@ enum Mode {
     ITERATION,
 
     /**
-     * Retry the the feature together with the setup and cleanup methods.
+     * Retry the feature together with the setup and cleanup methods.
      */
     SETUP_FEATURE_CLEANUP
   }

spock-specs/src/test/groovy/org/spockframework/smoke/extension/RetryPendingFeatureInteropSpec.groovy

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2025 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.spockframework.smoke.extension
+
+
+import spock.lang.Issue
+import spock.lang.PendingFeature
+import spock.lang.PendingFeatureIf
+import spock.lang.Retry
+import spock.lang.Specification
+
+import static spock.lang.Retry.Mode.ITERATION
+import static spock.lang.Retry.Mode.SETUP_FEATURE_CLEANUP
+
+/**
+ * This specification shall test the interoperation between {@link PendingFeature} and the {@link Retry} extension.
+ */
+@Issue("https://github.com/spockframework/spock/issues/1863")
+class RetryPendingFeatureInteropSpec extends Specification {
+
+  /**
+   * The interop between @PendingFeature and @Retry is tricky.
+   * If the PendingFeature is first the feature method interceptor is the outer one,
+   * whereas the retry will swallow the failure, and the the PendingFeature fails with PendingFeatureSuccessfulError.
+   * So this and the next test checks for the different interceptor combinations.
+   */
+  @PendingFeature
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  def "Retry feature shall be skipped when using PendingFeature"() {
+    expect:
+    false
+  }
+
+  /**
+   * See test above, where the order of the annotations is switch, where the retry is the outer interceptor.
+   */
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  @PendingFeature
+  def "Retry feature inverse annotation order shall be skipped when using PendingFeature"() {
+    expect:
+    false
+  }
+
+  @PendingFeatureIf({ true })
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  def "Retry feature shall be skipped when using PendingFeatureIf"() {
+    expect:
+    false
+  }
+
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  @PendingFeatureIf({ true })
+  def "Retry feature inverse annotation order shall be skipped when using PendingFeatureIf"() {
+    expect:
+    false
+  }
+
+  @PendingFeature
+  @Retry(mode = ITERATION)
+  def "Retry iteration shall be skipped when using PendingFeature"() {
+    expect:
+    false
+  }
+
+  @PendingFeature
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  def "Retry feature parameterized shall be skipped when using PendingFeature"() {
+    expect:
+    if (i)
+      throw new Exception()
+
+    where:
+    i << [1, 2]
+  }
+
+  @PendingFeature
+  @Retry(mode = ITERATION)
+  def "Retry iteration parameterized shall be skipped when using PendingFeature"() {
+    expect:
+    if (i)
+      throw new Exception()
+
+    where:
+    i << [1, 2]
+  }
+
+  @PendingFeatureIf({ true })
+  @Retry(mode = ITERATION)
+  def "Retry iteration parameterized shall be skipped when using PendingFeatureIf"() {
+    expect:
+    if (i)
+      throw new Exception()
+
+    where:
+    i << [1, 2]
+  }
+}

spock-specs/src/test/groovy/org/spockframework/smoke/extension/RetryTestAbortedExceptionInteropSpec.groovy

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2025 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.spockframework.smoke.extension
+
+import org.opentest4j.TestAbortedException
+import spock.lang.IgnoreIf
+import spock.lang.Issue
+import spock.lang.Requires
+import spock.lang.Retry
+import spock.lang.Specification
+
+import static spock.lang.Retry.Mode.ITERATION
+import static spock.lang.Retry.Mode.SETUP_FEATURE_CLEANUP
+
+/**
+ * This specification shall test the interoperation of API using the {@link TestAbortedException} and the {@link Retry} extension.
+ */
+@Issue("https://github.com/spockframework/spock/issues/1863")
+class RetryTestAbortedExceptionInteropSpec extends Specification {
+
+  @Retry(mode = ITERATION)
+  def "Retry iteration shall be skipped if a TestAbortedException is thrown"() {
+    expect:
+    throw new TestAbortedException()
+  }
+
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  def "Retry feature shall be skipped if a TestAbortedException is thrown"() {
+    expect:
+    throw new TestAbortedException()
+  }
+
+  @Retry(mode = ITERATION)
+  def "Retry iteration parameterized shall be skipped if a TestAbortedException is thrown"() {
+    expect:
+    if (i > 0)
+      throw new TestAbortedException("$i")
+
+    where:
+    i << [1, 2]
+  }
+
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  def "Retry feature parameterized shall be skipped if a TestAbortedException is thrown"() {
+    expect:
+    if (i > 0)
+      throw new TestAbortedException("$i")
+
+    where:
+    i << [1, 2]
+  }
+
+  @IgnoreIf({ true })
+  @Retry
+  def "Retry shall be skipped when feature is ignored"() {
+    expect:
+    false
+  }
+
+  @IgnoreIf({ true })
+  @Retry
+  def "Retry parameterized shall be skipped when feature is ignored"() {
+    expect:
+    false
+
+    where:
+    i << [1, 2]
+  }
+
+  @Requires({ false })
+  @Retry
+  def "Retry shall be skipped  when using Requires"() {
+    expect:
+    false
+  }
+
+  @Requires({ data.get("i") && false })
+  @Retry(mode = ITERATION)
+  def "Retry iteration parameterized shall be skipped when using Requires"() {
+    expect:
+    false
+
+    where:
+    i << [1, 2]
+  }
+
+  @Requires({ data.get("i") && false })
+  @Retry(mode = SETUP_FEATURE_CLEANUP)
+  def "Retry feature parameterized shall be skipped when using Requires"() {
+    expect:
+    false
+
+    where:
+    i << [1, 2]
+  }
+}