1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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 }