1 package org.apache.maven.shared.artifact.filter.resolve.transform;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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.sonatype.aether.graph.DependencyFilter;
40 import org.sonatype.aether.graph.Dependency;
41 import org.sonatype.aether.graph.DependencyNode;
42 import org.sonatype.aether.util.artifact.DefaultArtifact;
43 import org.sonatype.aether.util.filter.AndDependencyFilter;
44 import org.sonatype.aether.util.filter.ExclusionsDependencyFilter;
45 import org.sonatype.aether.util.filter.OrDependencyFilter;
46 import org.sonatype.aether.util.filter.PatternExclusionsDependencyFilter;
47 import org.sonatype.aether.util.filter.PatternInclusionsDependencyFilter;
48 import org.sonatype.aether.util.filter.ScopeDependencyFilter;
49 import org.sonatype.aether.util.graph.DefaultDependencyNode;
50 import org.junit.Test;
51
52 public class SonatypeAetherFilterTransformerTest
53 {
54
55 private SonatypeAetherFilterTransformer transformer = new SonatypeAetherFilterTransformer();
56
57 @Test
58 public void testTransformAndFilter()
59 {
60 AndFilter filter = new AndFilter(
61 Arrays.<TransformableFilter>asList( ScopeFilter.including( "compile" ),
62 new ExclusionsFilter( Collections.singletonList( "x:a" ) ) ) );
63
64 AndDependencyFilter dependencyFilter = (AndDependencyFilter) filter.transform( transformer );
65
66 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v", "compile" ), null ) );
67
68 assertFalse( dependencyFilter.accept( newDependencyNode( "x:a:v", "compile" ), null ) );
69
70 assertFalse( dependencyFilter.accept( newDependencyNode( "g:a:v", "test" ), null ) );
71
72 assertFalse( dependencyFilter.accept( newDependencyNode( "x:a:v", "test" ), null ) );
73 }
74
75 @Test
76 public void testTransformExclusionsFilter()
77 {
78 ExclusionsFilter filter = new ExclusionsFilter( Collections.singletonList( "x:a" ) );
79
80 ExclusionsDependencyFilter dependencyFilter = (ExclusionsDependencyFilter) filter.transform( transformer );
81
82 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v", "compile" ), null ) );
83
84 assertFalse( dependencyFilter.accept( newDependencyNode( "x:a:v", "compile" ), null ) );
85 }
86
87 @Test
88 public void testTransformOrFilter()
89 {
90 OrFilter filter = new OrFilter( Arrays.<TransformableFilter>asList( ScopeFilter.including( "compile" ),
91 ScopeFilter.including( "test" ) ) );
92
93 OrDependencyFilter dependencyFilter = (OrDependencyFilter) filter.transform( transformer );
94
95 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v", "compile" ), null ) );
96
97 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v", "test" ), null ) );
98
99 assertFalse( dependencyFilter.accept( newDependencyNode( "g:a:v", "runtime" ), null ) );
100 }
101
102 @Test
103 public void testTransformScopeFilter()
104 {
105 ScopeFilter filter = ScopeFilter.including( Collections.singletonList( "runtime" ) );
106
107 ScopeDependencyFilter dependencyFilter = (ScopeDependencyFilter) filter.transform( transformer );
108
109 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v", "runtime" ), null ) );
110
111 assertFalse( dependencyFilter.accept( newDependencyNode( "g:a:v", "compile" ), null ) );
112
113 assertFalse( dependencyFilter.accept( newDependencyNode( "g:a:v", "test" ), null ) );
114 }
115
116 @Test
117 public void testTransformPatternExclusionsFilter()
118 {
119 PatternExclusionsFilter filter =
120 new PatternExclusionsFilter( Collections.singletonList( "x:*" ) );
121
122 PatternExclusionsDependencyFilter dependencyFilter =
123 (PatternExclusionsDependencyFilter) filter.transform( transformer );
124
125 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v", "runtime" ), null ) );
126
127 assertFalse( dependencyFilter.accept( newDependencyNode( "x:a:v", "runtime" ), null ) );
128 }
129
130 @Test
131 public void testTransformPatternInclusionsFilter()
132 {
133 PatternInclusionsFilter filter =
134 new PatternInclusionsFilter( Collections.singletonList( "g:*" ) );
135
136 PatternInclusionsDependencyFilter dependencyFilter =
137 (PatternInclusionsDependencyFilter) filter.transform( transformer );
138
139 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v", "runtime" ), null ) );
140
141 assertFalse( dependencyFilter.accept( newDependencyNode( "x:a:v", "runtime" ), null ) );
142 }
143
144
145 @Test
146 public void testTransformClassifierPatternInclusionsFilter()
147 {
148 PatternInclusionsFilter filter =
149 new PatternInclusionsFilter( Collections.singletonList( "g:*:*:c:*" ) );
150
151 DependencyFilter dependencyFilter = filter.transform( transformer );
152
153 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:v:c:*", "runtime" ), null ) );
154
155 assertFalse( dependencyFilter.accept( newDependencyNode( "g:a:v", "runtime" ), null ) );
156
157 assertFalse( dependencyFilter.accept( newDependencyNode( "x:a:v:c:*", "runtime" ), null ) );
158 }
159
160 @Test
161 public void testTransformAbstractFilter() throws Exception
162 {
163 AbstractFilter snapshotFilter = new AbstractFilter()
164 {
165 @Override
166 public boolean accept( Node node, List<Node> parents )
167 {
168 return ArtifactUtils.isSnapshot( node.getDependency().getVersion() );
169 }
170 };
171
172 DependencyFilter dependencyFilter = snapshotFilter.transform( transformer );
173
174 assertTrue( dependencyFilter.accept( newDependencyNode( "g:a:1.0-SNAPSHOT", "compile" ), null ) );
175
176 assertFalse( dependencyFilter.accept( newDependencyNode( "g:a:1.0", "compile" ), null ) );
177 }
178
179 private DependencyNode newDependencyNode( String string, String scope )
180 {
181 return new DefaultDependencyNode( new Dependency( new DefaultArtifact( string ), scope ) );
182 }
183
184 }