1 package org.apache.maven.archiva.dependency.graph;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.util.ArrayList;
23 import java.util.Collection;
24 import java.util.List;
25
26 import org.apache.commons.collections.CollectionUtils;
27 import org.apache.commons.collections.Predicate;
28 import org.apache.commons.collections.functors.AndPredicate;
29 import org.apache.commons.collections.functors.NotPredicate;
30 import org.apache.commons.lang.StringUtils;
31 import org.apache.maven.archiva.dependency.graph.functors.EdgeExactScopePredicate;
32 import org.apache.maven.archiva.dependency.graph.functors.EdgeFromPredicate;
33 import org.apache.maven.archiva.dependency.graph.functors.NodeFromParentPredicate;
34 import org.apache.maven.archiva.dependency.graph.functors.NodePredicate;
35 import org.apache.maven.archiva.dependency.graph.functors.ToKeyTransformer;
36 import org.apache.maven.archiva.model.ArchivaProjectModel;
37 import org.apache.maven.archiva.model.ArtifactReference;
38 import org.apache.maven.archiva.model.Dependency;
39 import org.apache.maven.archiva.model.VersionedReference;
40 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
41
42
43
44
45
46
47 public abstract class AbstractDependencyGraphFactoryTestCase
48 extends PlexusInSpringTestCase
49 {
50 public class ExpectedEdge
51 {
52 public String from;
53
54 public String to;
55
56 public ExpectedEdge( String from, String to )
57 {
58 this.from = from;
59 this.to = to;
60 }
61 }
62
63 public class GraphEdgePredicate
64 implements Predicate
65 {
66 private String edgeFrom;
67
68 private String edgeTo;
69
70 public GraphEdgePredicate( String edgeFrom, String edgeTo )
71 {
72 this.edgeFrom = edgeFrom;
73 this.edgeTo = edgeTo;
74 }
75
76 public boolean evaluate( Object object )
77 {
78 boolean satisfies = false;
79
80 if ( object instanceof DependencyGraphEdge )
81 {
82 DependencyGraphEdge edge = (DependencyGraphEdge) object;
83 String actualFrom = ArtifactReference.toKey( edge.getNodeFrom() );
84 String actualTo = ArtifactReference.toKey( edge.getNodeTo() );
85
86 satisfies = ( StringUtils.equals( edgeFrom, actualFrom ) && StringUtils.equals( edgeTo, actualTo ) );
87 }
88
89 return satisfies;
90 }
91 }
92
93 @SuppressWarnings("unchecked")
94 protected void assertDirectNodes( DependencyGraph graph, List<DependencyGraphNode> expectedNodes, String scope )
95 {
96 DependencyGraphNode rootNode = graph.getRootNode();
97 List<DependencyGraphEdge> rootEdges = graph.getEdgesFrom( rootNode );
98 List<DependencyGraphEdge> actualEdges = new ArrayList<DependencyGraphEdge>();
99
100 Predicate directDep = NotPredicate.getInstance( new NodeFromParentPredicate() );
101 Predicate scopedDirectDeps = AndPredicate.getInstance( new EdgeExactScopePredicate( scope ), directDep );
102 CollectionUtils.select( rootEdges, scopedDirectDeps, actualEdges );
103
104
105 if ( expectedNodes.size() != actualEdges.size() )
106 {
107 StringBuffer sb = new StringBuffer();
108
109 sb.append( "Direct node.count with <" ).append( scope ).append( "> edges from [" );
110 sb.append( DependencyGraphKeys.toKey( rootNode.getArtifact() ) ).append( "]" ).append( " expected:<" );
111 sb.append( expectedNodes.size() ).append( "> but was:<" );
112 sb.append( actualEdges.size() ).append( ">" );
113
114 CollectionUtils.transform( actualEdges, new ToKeyTransformer() );
115
116 Collection<String> missingActualKeys = CollectionUtils.subtract( actualEdges, expectedNodes );
117 for ( String key : missingActualKeys )
118 {
119 sb.append( "\n (Extra Actual) " ).append( key );
120 }
121
122 Collection<String> missingExpectedKeys = CollectionUtils.subtract( expectedNodes, actualEdges );
123 for ( String key : missingExpectedKeys )
124 {
125 sb.append( "\n (Extra Expected) " ).append( key );
126 }
127
128 fail( sb.toString() );
129 }
130
131 for ( DependencyGraphEdge edge : actualEdges )
132 {
133 String actualKey = DependencyGraphKeys.toKey( edge.getNodeTo() );
134 assertTrue( "Direct <" + scope + "> node To [" + actualKey + "] exists in expectedNodes.", expectedNodes
135 .contains( actualKey ) );
136 }
137 }
138
139 protected void assertEdges( DependencyGraph graph, List<ExpectedEdge> expectedEdges )
140 {
141 assertNotNull( "Graph.edges should never be null.", graph.getEdges() );
142 assertEquals( "Graph.edges.size()", expectedEdges.size(), graph.getEdges().size() );
143
144 for ( ExpectedEdge expectedEdge : expectedEdges )
145 {
146 Predicate edgePredicate = new GraphEdgePredicate( expectedEdge.from, expectedEdge.to );
147
148 DependencyGraphEdge edge = (DependencyGraphEdge) CollectionUtils.find( graph.getEdges(), edgePredicate );
149 if ( edge == null )
150 {
151 fail( "Unable to find expected edge from:<" + expectedEdge.from + "> to:<" + expectedEdge.to + ">" );
152 }
153 }
154 }
155
156 @SuppressWarnings("unchecked")
157 protected void assertGraph( DependencyGraph graph, String rootRefKey, List expectedNodeKeys )
158 {
159 assertNotNull( "Graph.nodes should never be null.", graph.getNodes() );
160 assertTrue( "Graph.nodes.size() should always be 1 or better.", graph.getNodes().size() >= 1 );
161
162 ArtifactReference rootRef = graph.getRootNode().getArtifact();
163 StringBuffer actualRootRef = new StringBuffer();
164 actualRootRef.append( rootRef.getGroupId() ).append( ":" );
165 actualRootRef.append( rootRef.getArtifactId() ).append( ":" );
166 actualRootRef.append( rootRef.getVersion() );
167
168 assertEquals( "Graph.root", rootRefKey, actualRootRef.toString() );
169
170 List<DependencyGraphNode> actualNodes = new ArrayList<DependencyGraphNode>();
171
172 Predicate notRootNode = NotPredicate.getInstance( new NodePredicate( graph.getRootNode() ) );
173 CollectionUtils.select( graph.getNodes(), notRootNode, actualNodes );
174
175 boolean fail = false;
176 StringBuffer sb = new StringBuffer();
177
178 if ( expectedNodeKeys.size() != actualNodes.size() )
179 {
180 sb.append( "node.count expected:<" );
181 sb.append( expectedNodeKeys.size() ).append( "> but was:<" );
182 sb.append( actualNodes.size() ).append( ">" );
183 fail = true;
184 }
185
186 CollectionUtils.transform( actualNodes, new ToKeyTransformer() );
187
188 Collection<String> missingActualKeys = CollectionUtils.subtract( actualNodes, expectedNodeKeys );
189 for ( String key : missingActualKeys )
190 {
191 sb.append( "\n (Extra Actual) " ).append( key );
192 fail = true;
193 }
194
195 Collection<String> missingExpectedKeys = CollectionUtils.subtract( expectedNodeKeys, actualNodes );
196 for ( String key : missingExpectedKeys )
197 {
198 sb.append( "\n (Extra Expected) " ).append( key );
199 fail = true;
200 }
201
202 if( fail )
203 {
204 fail( sb.toString() );
205 }
206
207
208
209
210
211
212
213
214
215
216
217
218 }
219
220 @SuppressWarnings("unchecked")
221 protected void assertNodes( DependencyGraph graph, List<String> expectedNodeKeys )
222 {
223 assertNotNull( "Graph.nodes should never be null.", graph.getNodes() );
224 assertTrue( "Graph.nodes.size() should always be 1 or better.", graph.getNodes().size() >= 1 );
225
226
227 List<DependencyGraphNode> actualNodes = new ArrayList<DependencyGraphNode>();
228 actualNodes.addAll( graph.getNodes() );
229
230 if ( expectedNodeKeys.size() != actualNodes.size() )
231 {
232 StringBuffer sb = new StringBuffer();
233
234 sb.append( "node.count expected:<" );
235 sb.append( expectedNodeKeys.size() ).append( "> but was:<" );
236 sb.append( actualNodes.size() ).append( ">" );
237
238 CollectionUtils.transform( actualNodes, new ToKeyTransformer() );
239
240 Collection<String> missingActualKeys = CollectionUtils.subtract( actualNodes, expectedNodeKeys );
241 for ( String key : missingActualKeys )
242 {
243 sb.append( "\n (Extra Actual) " ).append( key );
244 }
245
246 Collection<String> missingExpectedKeys = CollectionUtils.subtract( expectedNodeKeys, actualNodes );
247 for ( String key : missingExpectedKeys )
248 {
249 sb.append( "\n (Extra Expected) " ).append( key );
250 }
251
252 fail( sb.toString() );
253 }
254
255 for ( DependencyGraphNode node : graph.getNodes() )
256 {
257 assertNotNull( "Artifact reference in node should not be null.", node.getArtifact() );
258 String key = ArtifactReference.toKey( node.getArtifact() );
259 assertTrue( "Artifact reference [" + key + "] should be in expectedNodeKeys.", expectedNodeKeys
260 .contains( key ) );
261 }
262 }
263
264 protected void assertRootNode( DependencyGraph graph, String expectedKey )
265 {
266 DependencyGraphNode node = graph.getRootNode();
267
268 String actualKey = DependencyGraphKeys.toKey( node.getArtifact() );
269 assertEquals( "Root Node", expectedKey, actualKey );
270 }
271
272 @SuppressWarnings("unchecked")
273 protected void assertTransientNodes( DependencyGraph graph, List<DependencyGraphNode> expectedNodes, String scope )
274 {
275
276 ArrayList<DependencyGraphEdge> actualEdges = new ArrayList<DependencyGraphEdge>();
277
278 DependencyGraphNode rootNode = graph.getRootNode();
279
280 Predicate transientDep = NotPredicate.getInstance( new EdgeFromPredicate( rootNode.getArtifact() ) );
281 Predicate edgeByExactScope = new EdgeExactScopePredicate( scope );
282 Predicate transitiveEdgesByScopePredicate = AndPredicate.getInstance( transientDep, edgeByExactScope );
283
284 CollectionUtils.select( graph.getEdges(), transitiveEdgesByScopePredicate, actualEdges );
285
286 if ( expectedNodes.size() != actualEdges.size() )
287 {
288 StringBuffer sb = new StringBuffer();
289
290 sb.append( "Transient node.count with <" ).append( scope ).append( "> edges from [" );
291 sb.append( DependencyGraphKeys.toKey( rootNode.getArtifact() ) ).append( "]" ).append( " expected:<" );
292 sb.append( expectedNodes.size() ).append( "> but was:<" );
293 sb.append( actualEdges.size() ).append( ">" );
294
295 CollectionUtils.transform( actualEdges, new ToKeyTransformer() );
296
297 Collection<DependencyGraphNode> missingActualKeys = CollectionUtils.subtract( actualEdges, expectedNodes );
298 for ( DependencyGraphNode key : missingActualKeys )
299 {
300 sb.append( "\n (Extra Actual) " ).append( key );
301 }
302
303 Collection<DependencyGraphNode> missingExpectedKeys = CollectionUtils.subtract( expectedNodes, actualEdges );
304 for ( DependencyGraphNode key : missingExpectedKeys )
305 {
306 sb.append( "\n (Extra Expected) " ).append( key );
307 }
308
309 fail( sb.toString() );
310 }
311
312 for ( DependencyGraphEdge edge : actualEdges )
313 {
314 String actualKey = DependencyGraphKeys.toKey( edge.getNodeTo() );
315 assertTrue( "Transient Node To [" + actualKey + "] exists in expectedNodes.", expectedNodes
316 .contains( actualKey ) );
317 }
318 }
319
320 protected Dependency toDependency( String key )
321 {
322 String parts[] = StringUtils.splitPreserveAllTokens( key, ':' );
323
324 assertEquals( "Dependency key [" + key + "] should be 5 parts.", 5, parts.length );
325
326 Dependency dep = new Dependency();
327
328 dep.setGroupId( parts[0] );
329 dep.setArtifactId( parts[1] );
330 dep.setVersion( parts[2] );
331 dep.setClassifier( parts[3] );
332 dep.setType( parts[4] );
333
334 return dep;
335 }
336
337 protected ArchivaProjectModel toModel( String key, Dependency deps[] )
338 {
339 String parts[] = StringUtils.splitPreserveAllTokens( key, ':' );
340
341 assertEquals( "Dependency key [" + key + "] should be 3 parts.", 3, parts.length );
342
343 ArchivaProjectModel model = new ArchivaProjectModel();
344 model.setGroupId( parts[0] );
345 model.setArtifactId( parts[1] );
346 model.setVersion( parts[2] );
347 model.setOrigin( "testcase" );
348 model.setPackaging( "jar" );
349
350 if ( deps != null )
351 {
352 for ( int i = 0; i < deps.length; i++ )
353 {
354 Dependency dep = deps[i];
355 model.addDependency( dep );
356 }
357 }
358
359 return model;
360 }
361
362 protected VersionedReference toVersionedReference( String key )
363 {
364 String parts[] = StringUtils.splitPreserveAllTokens( key, ':' );
365 assertEquals( "Versioned Reference [" + key + "] part count.", 3, parts.length );
366
367 VersionedReference ref = new VersionedReference();
368 ref.setGroupId( parts[0] );
369 ref.setArtifactId( parts[1] );
370 ref.setVersion( parts[2] );
371 return ref;
372 }
373 }