View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.maven.shared.artifact.filter.resolve.transform;
20  
21  import java.util.Arrays;
22  import java.util.Collections;
23  import java.util.List;
24  
25  import org.apache.maven.artifact.ArtifactUtils;
26  import org.apache.maven.shared.artifact.filter.resolve.AbstractFilter;
27  import org.apache.maven.shared.artifact.filter.resolve.AndFilter;
28  import org.apache.maven.shared.artifact.filter.resolve.ExclusionsFilter;
29  import org.apache.maven.shared.artifact.filter.resolve.Node;
30  import org.apache.maven.shared.artifact.filter.resolve.OrFilter;
31  import org.apache.maven.shared.artifact.filter.resolve.PatternExclusionsFilter;
32  import org.apache.maven.shared.artifact.filter.resolve.PatternInclusionsFilter;
33  import org.apache.maven.shared.artifact.filter.resolve.ScopeFilter;
34  import org.apache.maven.shared.artifact.filter.resolve.TransformableFilter;
35  import org.eclipse.aether.artifact.DefaultArtifact;
36  import org.eclipse.aether.graph.DefaultDependencyNode;
37  import org.eclipse.aether.graph.Dependency;
38  import org.eclipse.aether.graph.DependencyFilter;
39  import org.eclipse.aether.graph.DependencyNode;
40  import org.eclipse.aether.util.filter.AndDependencyFilter;
41  import org.eclipse.aether.util.filter.ExclusionsDependencyFilter;
42  import org.eclipse.aether.util.filter.OrDependencyFilter;
43  import org.eclipse.aether.util.filter.PatternExclusionsDependencyFilter;
44  import org.eclipse.aether.util.filter.PatternInclusionsDependencyFilter;
45  import org.eclipse.aether.util.filter.ScopeDependencyFilter;
46  import org.junit.Test;
47  
48  import static org.junit.Assert.assertFalse;
49  import static org.junit.Assert.assertTrue;
50  
51  public class EclipseAetherFilterTransformerTest {
52      private final EclipseAetherFilterTransformer transformer = new EclipseAetherFilterTransformer();
53  
54      @Test
55      public void testTransformAndFilter() {
56          AndFilter filter = new AndFilter(Arrays.asList(
57                  ScopeFilter.including("compile"), new ExclusionsFilter(Collections.singletonList("x:a"))));
58  
59          AndDependencyFilter dependencyFilter = (AndDependencyFilter) filter.transform(transformer);
60  
61          assertTrue(dependencyFilter.accept(
62                  newDependencyNode("g:a:v", "compile"), Collections.<DependencyNode>emptyList()));
63  
64          assertFalse(dependencyFilter.accept(
65                  newDependencyNode("x:a:v", "compile"), Collections.<DependencyNode>emptyList()));
66  
67          assertFalse(
68                  dependencyFilter.accept(newDependencyNode("g:a:v", "test"), Collections.<DependencyNode>emptyList()));
69  
70          assertFalse(
71                  dependencyFilter.accept(newDependencyNode("x:a:v", "test"), Collections.<DependencyNode>emptyList()));
72      }
73  
74      @Test
75      public void testTransformExclusionsFilter() {
76          ExclusionsFilter filter = new ExclusionsFilter(Collections.singletonList("x:a"));
77  
78          ExclusionsDependencyFilter dependencyFilter = (ExclusionsDependencyFilter) filter.transform(transformer);
79  
80          assertTrue(dependencyFilter.accept(
81                  newDependencyNode("g:a:v", "compile"), Collections.<DependencyNode>emptyList()));
82  
83          assertFalse(dependencyFilter.accept(
84                  newDependencyNode("x:a:v", "compile"), Collections.<DependencyNode>emptyList()));
85      }
86  
87      @Test
88      public void testTransformOrFilter() {
89          OrFilter filter = new OrFilter(
90                  Arrays.<TransformableFilter>asList(ScopeFilter.including("compile"), ScopeFilter.including("test")));
91  
92          OrDependencyFilter dependencyFilter = (OrDependencyFilter) filter.transform(transformer);
93  
94          assertTrue(dependencyFilter.accept(
95                  newDependencyNode("g:a:v", "compile"), Collections.<DependencyNode>emptyList()));
96  
97          assertTrue(
98                  dependencyFilter.accept(newDependencyNode("g:a:v", "test"), Collections.<DependencyNode>emptyList()));
99  
100         assertFalse(dependencyFilter.accept(
101                 newDependencyNode("g:a:v", "runtime"), Collections.<DependencyNode>emptyList()));
102     }
103 
104     @Test
105     public void testTransformScopeFilter() {
106         ScopeFilter filter = ScopeFilter.including(Collections.singletonList("runtime"));
107 
108         ScopeDependencyFilter dependencyFilter = (ScopeDependencyFilter) filter.transform(transformer);
109 
110         assertTrue(dependencyFilter.accept(
111                 newDependencyNode("g:a:v", "runtime"), Collections.<DependencyNode>emptyList()));
112 
113         assertFalse(dependencyFilter.accept(
114                 newDependencyNode("g:a:v", "compile"), Collections.<DependencyNode>emptyList()));
115 
116         assertFalse(
117                 dependencyFilter.accept(newDependencyNode("g:a:v", "test"), Collections.<DependencyNode>emptyList()));
118     }
119 
120     @Test
121     public void testTransformPatternExclusionsFilter() {
122         PatternExclusionsFilter filter = new PatternExclusionsFilter(Collections.singletonList("x:*"));
123 
124         PatternExclusionsDependencyFilter dependencyFilter =
125                 (PatternExclusionsDependencyFilter) filter.transform(transformer);
126 
127         assertTrue(dependencyFilter.accept(
128                 newDependencyNode("g:a:v", "runtime"), Collections.<DependencyNode>emptyList()));
129 
130         assertFalse(dependencyFilter.accept(
131                 newDependencyNode("x:a:v", "runtime"), Collections.<DependencyNode>emptyList()));
132     }
133 
134     @Test
135     public void testTransformPatternInclusionsFilter() {
136         PatternInclusionsFilter filter = new PatternInclusionsFilter(Collections.singletonList("g:*"));
137 
138         PatternInclusionsDependencyFilter dependencyFilter =
139                 (PatternInclusionsDependencyFilter) filter.transform(transformer);
140 
141         assertTrue(dependencyFilter.accept(
142                 newDependencyNode("g:a:v", "runtime"), Collections.<DependencyNode>emptyList()));
143 
144         assertFalse(dependencyFilter.accept(
145                 newDependencyNode("x:a:v", "runtime"), Collections.<DependencyNode>emptyList()));
146     }
147 
148     @Test
149     public void testTransformClassifierPatternInclusionsFilter() {
150         PatternInclusionsFilter filter = new PatternInclusionsFilter(Collections.singletonList("g:*:*:c:*"));
151 
152         DependencyFilter dependencyFilter = filter.transform(transformer);
153 
154         assertTrue(dependencyFilter.accept(
155                 newDependencyNode("g:a:v:c:*", "runtime"), Collections.<DependencyNode>emptyList()));
156 
157         assertFalse(dependencyFilter.accept(
158                 newDependencyNode("g:a:v", "runtime"), Collections.<DependencyNode>emptyList()));
159 
160         assertFalse(dependencyFilter.accept(
161                 newDependencyNode("x:a:v:c:*", "runtime"), Collections.<DependencyNode>emptyList()));
162     }
163 
164     @Test
165     public void testTransformAbstractFilter() {
166         AbstractFilter snapshotFilter = new AbstractFilter() {
167             @Override
168             public boolean accept(Node node, List<Node> parents) {
169                 return ArtifactUtils.isSnapshot(node.getDependency().getVersion());
170             }
171         };
172 
173         DependencyFilter dependencyFilter = snapshotFilter.transform(transformer);
174 
175         assertTrue(dependencyFilter.accept(
176                 newDependencyNode("g:a:1.0-SNAPSHOT", "compile"), Collections.<DependencyNode>emptyList()));
177 
178         assertFalse(dependencyFilter.accept(
179                 newDependencyNode("g:a:1.0", "compile"), Collections.<DependencyNode>emptyList()));
180     }
181 
182     private DependencyNode newDependencyNode(String string, String scope) {
183         return new DefaultDependencyNode(new Dependency(new DefaultArtifact(string), scope));
184     }
185 }