Fix #1342: avoid shared include/exclude filters in parallel dependency updates

versions-maven-plugin/src/main/java/org/codehaus/mojo/versions/AbstractVersionsDependencyUpdaterMojo.java

@@ -113,20 +113,6 @@ public abstract class AbstractVersionsDependencyUpdaterMojo extends AbstractVers
     @Parameter(property = "scope")
     private String scope = null;
 
-    /**
-     * Artifact filter to determine if artifact should be included
-     *
-     * @since 1.0-alpha-3
-     */
-    private PatternIncludesArtifactFilter includesFilter;
-
-    /**
-     * Artifact filter to determine if artifact should be excluded
-     *
-     * @since 1.0-alpha-3
-     */
-    private PatternExcludesArtifactFilter excludesFilter;
-
     /**
      * Whether to skip processing dependencies that are produced as part of the current reactor.
      *
@@ -393,29 +379,31 @@ protected boolean hasIncludes() {
     }
 
     private ArtifactFilter getIncludesArtifactFilter() {
-        if (includesFilter == null && (includes != null || includesList != null)) {
-            List<String> patterns = new ArrayList<>();
-            if (this.includesList != null) {
-                patterns.addAll(separatePatterns(includesList));
-            } else {
-                patterns.addAll(Arrays.asList(includes));
-            }
-            includesFilter = new PatternIncludesArtifactFilter(patterns);
+        if (includes == null && includesList == null) {
+            return null;
+        }
+
+        List<String> patterns = new ArrayList<>();
+        if (this.includesList != null) {
+            patterns.addAll(separatePatterns(includesList));
+        } else {
+            patterns.addAll(Arrays.asList(includes));
         }
-        return includesFilter;
+        return new PatternIncludesArtifactFilter(patterns);
     }
 
     private ArtifactFilter getExcludesArtifactFilter() {
-        if (excludesFilter == null && (excludes != null || excludesList != null)) {
-            List<String> patterns = new ArrayList<>();
-            if (excludesList != null) {
-                patterns.addAll(separatePatterns(excludesList));
-            } else {
-                patterns.addAll(Arrays.asList(excludes));
-            }
-            excludesFilter = new PatternExcludesArtifactFilter(patterns);
+        if (excludes == null && excludesList == null) {
+            return null;
+        }
+
+        List<String> patterns = new ArrayList<>();
+        if (excludesList != null) {
+            patterns.addAll(separatePatterns(excludesList));
+        } else {
+            patterns.addAll(Arrays.asList(excludes));
         }
-        return excludesFilter;
+        return new PatternExcludesArtifactFilter(patterns);
     }
 
     private ArtifactFilter getScopeArtifactFilter() {

versions-maven-plugin/src/test/java/org/codehaus/mojo/versions/SeparatePatternsForIncludesAnExcludesTest.java

@@ -1,5 +1,7 @@
 package org.codehaus.mojo.versions;
 
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.util.List;
 
 import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
@@ -14,6 +16,7 @@
 
 import static org.codehaus.mojo.versions.utils.MockUtils.mockArtifactHandlerManager;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
 import static org.mockito.MockitoAnnotations.openMocks;
 
 public class SeparatePatternsForIncludesAnExcludesTest {
@@ -114,4 +117,30 @@ public void testSeparatePatternsWithSeveralCommaSeparatedPatterns() {
         assertEquals("group:artifact:type:version3", patterns.get(2));
         assertEquals("group:artifact:type:version4", patterns.get(3));
     }
+
+    @Test
+    public void testIncludesAndExcludesFiltersAreNotCached() throws Exception {
+        setField(mojo, "includesList", "com.acme:demo");
+        setField(mojo, "excludesList", "com.acme:blocked");
+
+        Object includesFirst = invokeNoArgMethod(mojo, "getIncludesArtifactFilter");
+        Object includesSecond = invokeNoArgMethod(mojo, "getIncludesArtifactFilter");
+        assertNotSame(includesFirst, includesSecond);
+
+        Object excludesFirst = invokeNoArgMethod(mojo, "getExcludesArtifactFilter");
+        Object excludesSecond = invokeNoArgMethod(mojo, "getExcludesArtifactFilter");
+        assertNotSame(excludesFirst, excludesSecond);
+    }
+
+    private static void setField(Object target, String fieldName, Object value) throws Exception {
+        Field field = AbstractVersionsDependencyUpdaterMojo.class.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        field.set(target, value);
+    }
+
+    private static Object invokeNoArgMethod(Object target, String methodName) throws Exception {
+        Method method = AbstractVersionsDependencyUpdaterMojo.class.getDeclaredMethod(methodName);
+        method.setAccessible(true);
+        return method.invoke(target);
+    }
 }