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