Add implied features... (#1598)

Features can now imply or be implied by other features.
Implied features are executed as long as at least one implying feature is executed,
preventing their removal from the execution plan, through things such as `PostDiscoveryFilters`.
Implying features does not affect the execution order in any way.

Author: Vampire

spock-core/src/main/java/org/spockframework/runtime/FeatureNode.java

@@ -16,6 +16,10 @@ public FeatureNode(UniqueId uniqueId, String displayName, TestSource source, Run
     super(uniqueId, displayName, source, configuration, featureInfo);
   }
 
+  protected FeatureNode(FeatureNode other) {
+    super(other);
+  }
+
   @Override
   public Type getType() {
     return Type.CONTAINER;

spock-core/src/main/java/org/spockframework/runtime/ImplicationFeatureNode.java

@@ -0,0 +1,126 @@
+package org.spockframework.runtime;
+
+import org.junit.platform.engine.TestDescriptor;
+import org.junit.platform.engine.TestExecutionResult;
+import org.spockframework.runtime.model.FeatureInfo;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toList;
+
+/**
+ * A feature that is implied by one or multiple other features within the same specification,
+ * implies one or multiple other features within the same specification,
+ * or both.
+ * The actual test work is delegated to another feature node.
+ * This node makes sure the node is not removed from hierarchy e.g. due to filtering as long as one implying feature is still present.
+ */
+public class ImplicationFeatureNode extends FeatureNode {
+
+  private final FeatureNode delegate;
+
+  private boolean removedFromHierarchy;
+
+  public ImplicationFeatureNode(FeatureNode delegate) {
+    super(delegate);
+    this.delegate = delegate;
+  }
+
+  @Override
+  public Type getType() {
+    return delegate.getType();
+  }
+
+  @Override
+  public SpockExecutionContext prepare(SpockExecutionContext context) throws Exception {
+    return delegate.prepare(context);
+  }
+
+  @Override
+  public SpockExecutionContext before(SpockExecutionContext context) throws Exception {
+    return delegate.before(context);
+  }
+
+  @Override
+  public void around(SpockExecutionContext context, Invocation<SpockExecutionContext> invocation) {
+    delegate.around(context, invocation);
+  }
+
+  @Override
+  public SpockExecutionContext execute(SpockExecutionContext context, DynamicTestExecutor dynamicTestExecutor) throws Exception {
+    return delegate.execute(context, dynamicTestExecutor);
+  }
+
+  @Override
+  public void after(SpockExecutionContext context) throws Exception {
+    delegate.after(context);
+  }
+
+  @Override
+  public void nodeFinished(SpockExecutionContext context, TestDescriptor testDescriptor, TestExecutionResult result) {
+    delegate.nodeFinished(context, testDescriptor, result);
+  }
+
+  @Override
+  public void nodeSkipped(SpockExecutionContext context, TestDescriptor testDescriptor, SkipResult result) {
+    delegate.nodeSkipped(context, testDescriptor, result);
+  }
+
+  @Override
+  public SkipResult shouldBeSkipped(SpockExecutionContext context) throws Exception {
+    return delegate.shouldBeSkipped(context);
+  }
+
+  private boolean allImplyingFeaturesAreRemoved() {
+    return !findImplicationFeatureNodes(getNodeInfo().getImplyingFeatures())
+      .findAny()
+      .isPresent();
+  }
+
+  @Override
+  public void removeFromHierarchy() {
+    if (getNodeInfo().getImplyingFeatures().isEmpty() || allImplyingFeaturesAreRemoved()) {
+      Stream<ImplicationFeatureNode> impliedFeatureNodes = findImplicationFeatureNodes(getNodeInfo().getImpliedFeatures());
+      super.removeFromHierarchy();
+      // retry to remove implied features that were just preserved for this implying feature
+      impliedFeatureNodes
+        .filter(impliedFeature -> impliedFeature.removedFromHierarchy)
+        .forEach(TestDescriptor::removeFromHierarchy);
+    } else {
+      // do not remove from hierarchy but remember it should have been removed
+      removedFromHierarchy = true;
+    }
+  }
+
+  private Stream<ImplicationFeatureNode> findImplicationFeatureNodes(List<FeatureInfo> features) {
+    SpecNode specNode = getParent()
+      .map(SpecNode.class::cast)
+      .orElseThrow(AssertionError::new);
+
+    return features
+      .stream()
+      .map(featureInfo -> specNode
+        .getChildren()
+        .stream()
+        .map(FeatureNode.class::cast)
+        .filter(featureNode -> featureNode.getNodeInfo().equals(featureInfo))
+        .map(ImplicationFeatureNode.class::cast)
+        .collect(collectingAndThen(toList(), featureNodes -> {
+          switch (featureNodes.size()) {
+            case 0:
+              return null;
+
+            case 1:
+              return featureNodes.get(0);
+
+            default:
+              throw new AssertionError("Expected to find 0 or 1 node, but found multiple");
+          }
+        }))
+      )
+      .filter(Objects::nonNull);
+  }
+}

spock-core/src/main/java/org/spockframework/runtime/SpockEngineDiscoveryPostProcessor.java

@@ -18,20 +18,25 @@ SpockEngineDescriptor postProcessEngineDescriptor(UniqueId uniqueId, RunContext
     return processedEngineDescriptor;
   }
 
-  private SpockNode createNode(SpecNode specNode, FeatureInfo feature, RunnerConfiguration configuration) {
+  private FeatureNode createNode(SpecNode specNode, FeatureInfo feature, RunnerConfiguration configuration) {
+    FeatureNode result;
     if (feature.isParameterized()) {
-      return describeParameterizedFeature(specNode.getUniqueId(), feature, configuration);
+      result = describeParameterizedFeature(specNode.getUniqueId(), feature, configuration);
     } else {
-      return describeSimpleFeature(specNode.getUniqueId(), feature, configuration);
+      result = describeSimpleFeature(specNode.getUniqueId(), feature, configuration);
     }
+    if (!feature.getImplyingFeatures().isEmpty() || !feature.getImpliedFeatures().isEmpty()) {
+      result = new ImplicationFeatureNode(result);
+    }
+    return result;
   }
 
   private FeatureNode describeParameterizedFeature(UniqueId parentId, FeatureInfo feature,
                                                    RunnerConfiguration configuration) {
     return new ParameterizedFeatureNode(toUniqueId(parentId, feature), configuration, feature);
   }
 
-  private SpockNode describeSimpleFeature(UniqueId parentId, FeatureInfo feature, RunnerConfiguration configuration) {
+  private FeatureNode describeSimpleFeature(UniqueId parentId, FeatureInfo feature, RunnerConfiguration configuration) {
     IterationInfo iterationInfo = new IterationInfo(feature, 0, EMPTY_ARGS, 1);
     iterationInfo.setName(feature.getName());
     UniqueId uniqueId = toUniqueId(parentId, feature);

spock-core/src/main/java/org/spockframework/runtime/SpockNode.java

@@ -27,6 +27,12 @@ protected SpockNode(UniqueId uniqueId, String displayName, TestSource source,
     this.nodeInfo = nodeInfo;
   }
 
+  protected SpockNode(SpockNode<T> other) {
+    super(other.getUniqueId(), other.getDisplayName(), other.getSource().orElse(null));
+    this.configuration = other.configuration;
+    this.nodeInfo = other.nodeInfo;
+  }
+
   public T getNodeInfo() {
     return nodeInfo;
   }

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

@@ -71,6 +71,10 @@ private void includeFeaturesBeforeLastIncludedFeature(SpecInfo spec) {
       FeatureInfo feature = features.get(i);
       if (includeRemaining) feature.setExcluded(false);
       else if (!feature.isExcluded()) includeRemaining = true;
+
+      if (i > 0) {
+        feature.addImpliedFeature(features.get(i - 1));
+      }
     }
   }
 

spock-core/src/main/java/org/spockframework/runtime/model/FeatureInfo.java

@@ -34,6 +34,10 @@ public class FeatureInfo extends SpecElementInfo<SpecInfo, AnnotatedElement> imp
   private final List<DataProviderInfo> dataProviders = new ArrayList<>();
   private final IterationFilter iterationFilter = new IterationFilter();
 
+  private final List<FeatureInfo> implyingFeatures = new ArrayList<>();
+
+  private final List<FeatureInfo> impliedFeatures = new ArrayList<>();
+
   private boolean reportIterations = true;
 
   private boolean forceParameterized = false;
@@ -119,6 +123,71 @@ public void addDataProvider(DataProviderInfo dataProvider) {
     dataProviders.add(dataProvider);
   }
 
+  /**
+   * Returns the features that imply this feature.
+   * All features are within the same specification hierarchy as this feature.
+   * If one of the returned features is going to be executed, this feature is also going to be executed,
+   * even if for example a post discovery filter would have filtered out this feature, like IDEs and build
+   * tools do if a specific test or a pattern of tests is executed.
+   *
+   * <p><b>NOTE:</b> This relationship does not imply any ordering constraint. According to configured
+   *                 run order and parallel execution settings the features can run in any order or even
+   *                 concurrently.
+   *
+   * @return the features that imply this feature
+   */
+  @Beta
+  public List<FeatureInfo> getImplyingFeatures() {
+    return implyingFeatures;
+  }
+
+  /**
+   * Returns the features this feature implies.
+   * All features are within the same specification hierarchy as this feature.
+   * If this feature is going to be executed, the returned features are also going to be executed,
+   * even if for example a post discovery filter would have filtered them out, like IDEs and build
+   * tools do if a specific test or a pattern of tests is executed.
+   *
+   * <p><b>NOTE:</b> This relationship does not imply any ordering constraint. According to configured
+   *                 run order and parallel execution settings the features can run in any order or even
+   *                 concurrently.
+   *
+   * @return the features this feature implies
+   */
+  @Beta
+  public List<FeatureInfo> getImpliedFeatures() {
+    return impliedFeatures;
+  }
+
+  /**
+   * Adds the given feature as implied by this feature.
+   * The given feature must be within the same specification hierarchy as this feature.
+   * If this feature is going to be executed, the given feature is also going to be executed,
+   * even if for example a post discovery filter would have filtered out the given feature,
+   * like IDEs and build tools do if a specific test or a pattern of tests is executed.
+   *
+   * <p><b>NOTE:</b> This relationship does not imply any ordering constraint. According to configured
+   *                 run order and parallel execution settings the features can run in any order or even
+   *                 concurrently.
+   *
+   * @param feature a feature that should be implied by this feature
+   */
+  @Beta
+  public void addImpliedFeature(FeatureInfo feature) {
+    if (equals(feature)) {
+      throw new IllegalArgumentException("Features cannot imply themselves");
+    }
+
+    Class<?> otherClass = feature.getParent().getReflection();
+    Class<?> clazz = getParent().getReflection();
+    if (!otherClass.isAssignableFrom(clazz) && !clazz.isAssignableFrom(otherClass)) {
+      throw new IllegalArgumentException("Features can only imply features within the same specification hierarchy");
+    }
+
+    impliedFeatures.add(feature);
+    feature.implyingFeatures.add(this);
+  }
+
   @Override
   public void addExclusiveResource(ExclusiveResource exclusiveResource) {
     exclusiveResources.add(exclusiveResource);