Make @PendingFeatureIf repeatable (#1030) (#1191)

Author: Vampire

docs/extensions.adoc

@@ -218,15 +218,20 @@ and only if all iterations become successful will be marked as failing. But if t
 does reference valid data variables, the individual iterations where the condition holds are
 deemed pending and each will individually fail as soon as it would be successful without this annotation.
 
-[source,groovy]
+[source,groovy,indent=0]
 ----
-@PendingFeatureIf({ os.windows })
-def "I'm not yet implemented on windows, but I am on other operating systems"() { ... }
+include::{sourcedir}/extension/PendingFeatureIfDocSpec.groovy[tag=example-a]
 
-@PendingFeatureIf({ sys.targetEnvironment == "prod" })
-def "This feature isn't deployed out to production yet, and isn't expected to pass"() { ... }
+include::{sourcedir}/extension/PendingFeatureIfDocSpec.groovy[tag=example-b]
 ----
 
+It is also supported to have multiple `@PendingFeatureIf` annotations or a mixture of `@PendingFeatureIf` and
+`@PendingFeature`, for example to ignore certain exceptions only under certain conditions.
+
+[source,groovy,indent=0]
+----
+include::{sourcedir}/extension/PendingFeatureIfDocSpec.groovy[tag=example-c]
+----
 
 === Stepwise
 

docs/release_notes.adoc

@@ -18,6 +18,8 @@ include::include.adoc[]
 
 - `@IgnoreIf` is now repeatable
 
+- `@PendingFeatureIf` is now repeatable
+
 - `@Requires` is now repeatable
 
 - `@See` is now repeatable

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

@@ -6,10 +6,7 @@
 import org.spockframework.runtime.extension.builtin.PreconditionContext;
 import org.spockframework.util.Beta;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 /**
  * Marks the annotated feature or selected iterations as {@link PendingFeature} if the
@@ -31,6 +28,7 @@
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.METHOD})
 @ExtensionAnnotation(PendingFeatureIfExtension.class)
+@Repeatable(PendingFeatureIf.Container.class)
 public @interface PendingFeatureIf {
 
   /**
@@ -58,4 +56,14 @@
    * @return reason why this feature is pending
    */
   String reason() default "";
+
+  /**
+   * @since 2.0
+   */
+  @Beta
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target({ElementType.METHOD})
+  @interface Container {
+    PendingFeatureIf[] value();
+  }
 }

spock-specs/src/test/groovy/org/spockframework/docs/extension/PendingFeatureIfDocSpec.groovy

@@ -0,0 +1,40 @@
+package org.spockframework.docs.extension
+
+import org.opentest4j.TestAbortedException
+import spock.lang.PendingFeature
+import spock.lang.PendingFeatureIf
+import spock.lang.Specification
+
+class PendingFeatureIfDocSpec extends Specification {
+// tag::example-a[]
+  @PendingFeatureIf({ os.windows })
+  def "I'm not yet implemented on windows, but I am on other operating systems"() {
+// end::example-a[]
+    expect:
+    throw new TestAbortedException()
+  }
+
+// tag::example-b[]
+  @PendingFeatureIf({ sys.targetEnvironment == "prod" })
+  def "This feature isn't deployed out to production yet, and isn't expected to pass"() {
+// end::example-b[]
+    expect:
+    true
+  }
+
+// tag::example-c[]
+  @PendingFeature(exceptions = UnsupportedOperationException)
+  @PendingFeatureIf(
+    exceptions = IllegalArgumentException,
+    value = { os.windows },
+    reason = 'Does not yet work on Windows')
+  @PendingFeatureIf(
+    exceptions = IllegalAccessException,
+    value = { jvm.java8 },
+    reason = 'Does not yet work on Java 8')
+  def "I have various problems in certain situations"() {
+// end::example-c[]
+    expect:
+    throw new TestAbortedException()
+  }
+}

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

@@ -23,6 +23,27 @@ def bar() {
     result.testsSucceededCount == 0
   }
 
+  def "@PendingFeatureIf marks failing feature as skipped if the condition passes and the test fails even if applied twice"() {
+    when:
+    def result = runner.runWithImports("""import spock.lang.PendingFeature
+import spock.lang.PendingFeatureIf
+
+class Foo extends Specification {
+  @PendingFeatureIf({true})
+  @PendingFeatureIf({true})
+  def bar() {
+    expect: false
+  }
+}
+    """)
+
+    then:
+    notThrown(AssertionError)
+    result.runCount == 1
+    result.failureCount == 0
+    result.ignoreCount == 0
+  }
+
   def "@PendingFeatureIf marks passing feature as failed if the conditional expression returns true"() {
     when:
     runner.runSpecBody """
@@ -37,6 +58,24 @@ def bar() {
     e.message == "Feature is marked with @PendingFeatureIf but passes unexpectedly"
   }
 
+  def "@PendingFeatureIf marks passing feature as failed if the conditional expression returns true even if applied twice"() {
+    when:
+    def result = runner.runWithImports("""import spock.lang.PendingFeature
+import spock.lang.PendingFeatureIf
+
+class Foo extends Specification {
+  @PendingFeatureIf({true})
+  @PendingFeatureIf({true})
+  def bar() {
+    expect: true
+  }
+}
+    """)
+    then:
+        AssertionError e = thrown(AssertionError)
+        e.message == "Feature is marked with @PendingFeatureIf but passes unexpectedly"
+  }
+
   def "@PendingFeatureIf marks passing feature as failed if the conditional expression returns true even if @PendingFeature is applied first"() {
     when:
     runner.runSpecBody """
@@ -182,6 +221,26 @@ def bar() {
     result.testsSucceededCount == 1
   }
 
+  def "@PendingFeatureIf marks failing feature as skipped if the data variable accessing condition passes and the test fails even if applied twice"() {
+    when:
+    def result = runner.runSpecBody """
+@PendingFeatureIf({ a == 1 })
+@PendingFeatureIf({ a == 1 })
+def bar() {
+  expect: a == 2
+  where: a = 1
+}
+"""
+
+    then:
+    notThrown(AssertionError)
+    result.testsStartedCount == 2
+    result.testsFailedCount == 0
+    result.testsSkippedCount == 0
+    result.testsAbortedCount == 1
+    result.testsSucceededCount == 1
+  }
+
   def "@PendingFeatureIf marks passing feature as failed if the data variable accessing conditional expression returns true"() {
     when:
     runner.runSpecBody """
@@ -197,6 +256,22 @@ def bar() {
     e.message == "Feature is marked with @PendingFeatureIf but passes unexpectedly"
   }
 
+  def "@PendingFeatureIf marks passing feature as failed if the data variable accessing conditional expression returns true even if applied twice"() {
+    when:
+    runner.runSpecBody """
+@PendingFeatureIf({ a == 2 })
+@PendingFeatureIf({ a == 2 })
+def bar() {
+  expect: a == 2
+  where: a = 2
+}
+"""
+
+    then:
+    AssertionError e = thrown()
+    e.message == "Feature is marked with @PendingFeatureIf but passes unexpectedly"
+  }
+
   def "@PendingFeatureIf marks failing feature as failed if the data variable accessing conditional expression returns false"() {
     when:
     runner.runSpecBody """