Merge pull request #1437 from hcoles/feature/test_filters

test filter extension point

Author: hcoles

.github/workflows/ci.yml

@@ -28,7 +28,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: ${{ matrix.java }}
-          distribution: adopt
+          distribution: temurin
       - name: 'Display JDK version'
         run: java -version
       - name: Cache local Maven repository

.github/workflows/release.yml

@@ -28,7 +28,7 @@ jobs:
       - name: Setup Java JDK
         uses: actions/setup-java@v4
         with:
-          distribution: adopt
+          distribution: temurin
           java-version: 11
           server-id: central
           server-username: MAVEN_USERNAME

.github/workflows/snapshot.yml

@@ -19,7 +19,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: 11
-          distribution: adopt
+          distribution: temurin
           server-id: central
           server-username: MAVEN_USERNAME
           server-password: MAVEN_PASSWORD

pitest-entry/src/main/java/org/pitest/mutationtest/build/FilteringPrioritiser.java

@@ -0,0 +1,32 @@
+package org.pitest.mutationtest.build;
+
+import org.pitest.classpath.CodeSource;
+import org.pitest.coverage.CoverageDatabase;
+
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+public class FilteringPrioritiser implements TestPrioritiserFactory {
+
+    private final TestPrioritiserFactory delegate;
+    private final TestFilter filter;
+
+    public FilteringPrioritiser(TestPrioritiserFactory delegate, TestFilter filter) {
+        this.delegate = delegate;
+        this.filter = filter;
+    }
+
+    @Override
+    public TestPrioritiser makeTestPrioritiser(Properties props, CodeSource code, CoverageDatabase coverage) {
+        TestPrioritiser p = delegate.makeTestPrioritiser(props, code, coverage);
+
+        return mutation -> p.assignTests(mutation).stream()
+                .filter(test -> filter.include(test, mutation))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public String description() {
+        return "Internal prioritiser factory";
+    }
+}

pitest-entry/src/main/java/org/pitest/mutationtest/build/TestFilter.java

@@ -0,0 +1,15 @@
+package org.pitest.mutationtest.build;
+
+import org.pitest.coverage.TestInfo;
+import org.pitest.mutationtest.engine.MutationDetails;
+
+import java.util.List;
+
+public interface TestFilter {
+   boolean include(TestInfo test, MutationDetails mutant);
+
+   static TestFilter combine(List<TestFilter> filters) {
+       return (test, mutant) -> filters.stream()
+               .allMatch(f -> f.include(test, mutant));
+   }
+}

pitest-entry/src/main/java/org/pitest/mutationtest/build/TestFilterFactory.java

@@ -0,0 +1,10 @@
+package org.pitest.mutationtest.build;
+
+import org.pitest.plugin.ProvidesFeature;
+import org.pitest.plugin.ToolClasspathPlugin;
+
+public interface TestFilterFactory extends ToolClasspathPlugin, ProvidesFeature {
+
+    TestFilter makeFilter(TestFilterParams params);
+
+}

pitest-entry/src/main/java/org/pitest/mutationtest/build/TestFilterParams.java

@@ -0,0 +1,16 @@
+package org.pitest.mutationtest.build;
+
+import org.pitest.plugin.FeatureSetting;
+
+public class TestFilterParams {
+    private final FeatureSetting conf;
+
+    public TestFilterParams(FeatureSetting conf) {
+        this.conf = conf;
+    }
+
+    public FeatureSetting conf() {
+        return conf;
+    }
+
+}

pitest-entry/src/main/java/org/pitest/mutationtest/config/PluginServices.java

@@ -10,6 +10,7 @@
 import org.pitest.mutationtest.MutationResultListenerFactory;
 import org.pitest.mutationtest.build.MutationGrouperFactory;
 import org.pitest.mutationtest.build.MutationInterceptorFactory;
+import org.pitest.mutationtest.build.TestFilterFactory;
 import org.pitest.mutationtest.build.TestPrioritiserFactory;
 import org.pitest.mutationtest.engine.gregor.MethodMutatorFactory;
 import org.pitest.mutationtest.engine.gregor.MutatorInfo;
@@ -65,6 +66,7 @@ public Collection<? extends ToolClasspathPlugin> findToolClasspathPlugins() {
     l.addAll(findCoverageExport());
     l.addAll(findStandAloneMutatorInfos());
     l.addAll(findTestStatListeners());
+    l.addAll(findTestFilters());
     return l;
   }
 
@@ -148,6 +150,11 @@ public List<TestStatListenerFactory> findTestStatListeners() {
     return new ArrayList<>(load(TestStatListenerFactory.class));
   }
 
+
+  public List<TestFilterFactory> findTestFilters() {
+      return new ArrayList<>(load(TestFilterFactory.class));
+  }
+
   public List<MutatorInfo> findMutatorInfos() {
     List<MutatorInfo> combined = findMutationOperators().stream()
             .filter(p -> p instanceof MutatorInfo)

pitest-entry/src/main/java/org/pitest/mutationtest/config/SettingsFactory.java

@@ -21,8 +21,12 @@
 import org.pitest.mutationtest.build.CompoundInterceptorFactory;
 import org.pitest.mutationtest.build.DefaultMutationGrouperFactory;
 import org.pitest.mutationtest.build.DefaultTestPrioritiserFactory;
+import org.pitest.mutationtest.build.FilteringPrioritiser;
 import org.pitest.mutationtest.build.MutationGrouperFactory;
 import org.pitest.mutationtest.build.MutationInterceptorFactory;
+import org.pitest.mutationtest.build.TestFilter;
+import org.pitest.mutationtest.build.TestFilterFactory;
+import org.pitest.mutationtest.build.TestFilterParams;
 import org.pitest.mutationtest.build.TestPrioritiserFactory;
 import org.pitest.mutationtest.incremental.DefaultHistoryFactory;
 import org.pitest.mutationtest.verify.BuildVerifierFactory;
@@ -88,6 +92,19 @@ public TestStatListener createTestStatListener() {
     return new CompoundTestStatListener(listeners);
   }
 
+  public TestFilter createTestFilter() {
+    FeatureParser parser = new FeatureParser();
+    List<TestFilterFactory> available = plugins.findTestFilters();
+    FeatureSelector<TestFilterFactory> features = new FeatureSelector<>(parser.parseFeatures(this.options.getFeatures()), available);
+    List<TestFilterFactory> enabled = features.getActiveFeatures();
+
+    List<TestFilter> filters = enabled.stream()
+            .map(f -> f.makeFilter(new TestFilterParams(features.getSettingForFeature(f.provides().name()))))
+            .collect(Collectors.toList());
+    return TestFilter.combine(filters);
+  }
+
+
   public MutationEngineFactory createEngine() {
     for (final MutationEngineFactory each : this.plugins.findMutationEngines()) {
       if (each.name().equals(this.options.getMutationEngine())) {
@@ -193,7 +210,8 @@ public void checkRequestedFeatures() {
   public TestPrioritiserFactory getTestPrioritiser() {
     final Collection<? extends TestPrioritiserFactory> testPickers = this.plugins
         .findTestPrioritisers();
-    return firstOrDefault(testPickers, new DefaultTestPrioritiserFactory());
+    TestFilter filter = createTestFilter();
+    return new FilteringPrioritiser(firstOrDefault(testPickers, new DefaultTestPrioritiserFactory()), filter);
   }
 
   public CoverageOptions createCoverageOptions() {

pitest-entry/src/test/java/org/pitest/mutationtest/build/FilteringPrioritiserTest.java

@@ -0,0 +1,62 @@
+package org.pitest.mutationtest.build;
+
+import org.junit.Test;
+import org.pitest.classinfo.ClassName;
+import org.pitest.classpath.CodeSource;
+import org.pitest.coverage.CoverageDatabase;
+import org.pitest.coverage.TestInfo;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Properties;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FilteringPrioritiserTest {
+
+    @Test
+    public void appliesFilterToPrioritisedTestWhenFalse() {
+        TestFilter alwaysFalse = (t, m) -> false;
+        List<TestInfo> tests = asList(aTest(), aTest());
+        FilteringPrioritiser underTest = new FilteringPrioritiser(alwaysSupply(tests), alwaysFalse);
+
+        TestPrioritiser prioritiser = underTest.makeTestPrioritiser(new Properties(), unused(), unused());
+
+        assertThat(prioritiser.assignTests(unused())).isEmpty();
+    }
+
+    @Test
+    public void appliesFilterToPrioritisedTestWhenTrue() {
+        TestFilter alwaysTrue = (t, m) -> true;
+        List<TestInfo> tests = asList(aTest(), aTest());
+        FilteringPrioritiser underTest = new FilteringPrioritiser(alwaysSupply(tests), alwaysTrue);
+
+        TestPrioritiser prioritiser = underTest.makeTestPrioritiser(new Properties(), unused(), unused());
+
+        assertThat(prioritiser.assignTests(unused())).containsExactlyElementsOf(tests);
+    }
+
+
+    private <T> T unused() {
+        return null;
+    }
+
+    private TestInfo aTest() {
+        return new TestInfo("foo", "bar", 1, Optional.<ClassName> empty(), 0);
+    }
+
+    private TestPrioritiserFactory alwaysSupply(List<TestInfo> tests) {
+        return  new TestPrioritiserFactory() {
+            @Override
+            public String description() {
+                return "";
+            }
+
+            @Override
+            public TestPrioritiser makeTestPrioritiser(Properties props, CodeSource code, CoverageDatabase coverage) {
+                return m -> tests;
+            }
+        };
+    }
+}