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;
20  
21  import java.util.ArrayList;
22  import java.util.Arrays;
23  import java.util.Collections;
24  import java.util.List;
25  
26  import junit.framework.TestCase;
27  
28  import org.apache.maven.artifact.Artifact;
29  import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
30  import org.apache.maven.shared.tools.easymock.MockManager;
31  import org.easymock.MockControl;
32  
33  public abstract class PatternArtifactFilterTCK
34      extends TestCase
35  {
36  
37      private final MockManager mockManager = new MockManager();
38  
39      protected abstract ArtifactFilter createFilter( List patterns );
40  
41      protected abstract ArtifactFilter createFilter( List patterns, boolean actTransitively );
42  
43      protected abstract boolean isInclusionExpected();
44  
45      public void testShouldTriggerBothPatternsWithWildcards()
46      {
47          final String groupId1 = "group";
48          final String artifactId1 = "artifact";
49  
50          final String groupId2 = "group2";
51          final String artifactId2 = "artifact2";
52  
53          final ArtifactMockAndControl mac1 = new ArtifactMockAndControl( groupId1, artifactId1 );
54          final ArtifactMockAndControl mac2 = new ArtifactMockAndControl( groupId2, artifactId2 );
55  
56          mockManager.replayAll();
57  
58          final List patterns = new ArrayList();
59          patterns.add( groupId1 + ":" + artifactId1 + ":*" );
60          patterns.add( groupId2 + ":" + artifactId2 + ":*" );
61  
62          final ArtifactFilter filter = createFilter( patterns );
63  
64          if ( !isInclusionExpected() )
65          {
66              assertFalse( filter.include( mac1.artifact ) );
67              assertFalse( filter.include( mac2.artifact ) );
68          }
69          else
70          {
71              assertTrue( filter.include( mac1.artifact ) );
72              assertTrue( filter.include( mac2.artifact ) );
73          }
74  
75          mockManager.verifyAll();
76      }
77  
78      public void testShouldTriggerBothPatternsWithNonColonWildcards()
79      {
80          final String groupId1 = "group";
81          final String artifactId1 = "artifact";
82  
83          final String groupId2 = "group2";
84          final String artifactId2 = "artifact2";
85  
86          final ArtifactMockAndControl mac1 = new ArtifactMockAndControl( groupId1, artifactId1 );
87          final ArtifactMockAndControl mac2 = new ArtifactMockAndControl( groupId2, artifactId2 );
88  
89          mockManager.replayAll();
90  
91          final List patterns = new ArrayList();
92          patterns.add( groupId1 + "*" );
93          patterns.add( groupId2 + "*" );
94  
95          final ArtifactFilter filter = createFilter( patterns );
96  
97          if ( !isInclusionExpected() )
98          {
99              assertFalse( filter.include( mac1.artifact ) );
100             assertFalse( filter.include( mac2.artifact ) );
101         }
102         else
103         {
104             assertTrue( filter.include( mac1.artifact ) );
105             assertTrue( filter.include( mac2.artifact ) );
106         }
107 
108         mockManager.verifyAll();
109     }
110 
111     public void testShouldIncludeDirectlyMatchedArtifactByGroupIdArtifactId()
112     {
113         final String groupId = "group";
114         final String artifactId = "artifact";
115 
116         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
117 
118         mockManager.replayAll();
119 
120         final ArtifactFilter filter = createFilter( Collections.singletonList( groupId + ":" + artifactId ) );
121 
122         if ( !isInclusionExpected() )
123         {
124             assertFalse( filter.include( mac.artifact ) );
125         }
126         else
127         {
128             assertTrue( filter.include( mac.artifact ) );
129         }
130 
131         mockManager.verifyAll();
132     }
133 
134     public void testShouldIncludeDirectlyMatchedArtifactByDependencyConflictId()
135     {
136         final String groupId = "group";
137         final String artifactId = "artifact";
138 
139         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
140 
141         mockManager.replayAll();
142 
143         final ArtifactFilter filter = createFilter( Collections.singletonList( groupId + ":" + artifactId + ":jar" ) );
144 
145         if ( !isInclusionExpected() )
146         {
147             assertFalse( filter.include( mac.artifact ) );
148         }
149         else
150         {
151             assertTrue( filter.include( mac.artifact ) );
152         }
153 
154         mockManager.verifyAll();
155     }
156 
157     public void testShouldNotIncludeWhenGroupIdDiffers()
158     {
159         final String groupId = "group";
160         final String artifactId = "artifact";
161 
162         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
163 
164         mockManager.replayAll();
165         final List patterns = new ArrayList();
166 
167         patterns.add( "otherGroup:" + artifactId + ":jar" );
168         patterns.add( "otherGroup:" + artifactId );
169 
170         final ArtifactFilter filter = createFilter( patterns );
171 
172         if ( !isInclusionExpected() )
173         {
174             assertTrue( filter.include( mac.artifact ) );
175         }
176         else
177         {
178             assertFalse( filter.include( mac.artifact ) );
179         }
180 
181         mockManager.verifyAll();
182     }
183 
184     public void testShouldNotIncludeWhenArtifactIdDiffers()
185     {
186         final String groupId = "group";
187         final String artifactId = "artifact";
188 
189         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
190 
191         mockManager.replayAll();
192 
193         final List patterns = new ArrayList();
194 
195         patterns.add( groupId + "otherArtifact:jar" );
196         patterns.add( groupId + "otherArtifact" );
197 
198         final ArtifactFilter filter = createFilter( patterns );
199 
200         if ( !isInclusionExpected() )
201         {
202             assertTrue( filter.include( mac.artifact ) );
203         }
204         else
205         {
206             assertFalse( filter.include( mac.artifact ) );
207         }
208 
209         mockManager.verifyAll();
210     }
211 
212     public void testShouldNotIncludeWhenBothIdElementsDiffer()
213     {
214         final String groupId = "group";
215         final String artifactId = "artifact";
216 
217         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
218 
219         mockManager.replayAll();
220 
221         final List patterns = new ArrayList();
222 
223         patterns.add( "otherGroup:otherArtifact:jar" );
224         patterns.add( "otherGroup:otherArtifact" );
225 
226         final ArtifactFilter filter = createFilter( patterns );
227 
228         if ( !isInclusionExpected() )
229         {
230             assertTrue( filter.include( mac.artifact ) );
231         }
232         else
233         {
234             assertFalse( filter.include( mac.artifact ) );
235         }
236 
237         mockManager.verifyAll();
238     }
239 
240     public void testShouldIncludeWhenPatternMatchesDependencyTrailAndTransitivityIsEnabled()
241     {
242         final String groupId = "group";
243         final String artifactId = "artifact";
244 
245         final String rootDepTrailItem = "current:project:jar:1.0";
246         final String depTrailItem = "otherGroup:otherArtifact";
247 
248         final List depTrail = Arrays.asList( new String[] { rootDepTrailItem, depTrailItem + ":jar:1.0" } );
249         final List patterns = Collections.singletonList( depTrailItem );
250 
251         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId, depTrail );
252 
253         mockManager.replayAll();
254 
255         final ArtifactFilter filter = createFilter( patterns, true );
256 
257         if ( !isInclusionExpected() )
258         {
259             assertFalse( filter.include( mac.artifact ) );
260         }
261         else
262         {
263             assertTrue( filter.include( mac.artifact ) );
264         }
265 
266         mockManager.verifyAll();
267     }
268 
269     public void testIncludeWhenPatternMatchesDepTrailWithTransitivityUsingNonColonWildcard()
270     {
271         final String groupId = "group";
272         final String artifactId = "artifact";
273 
274         final String rootDepTrailItem = "current:project:jar:1.0";
275         final String depTrailItem = "otherGroup:otherArtifact";
276 
277         final List depTrail = Arrays.asList( new String[] { rootDepTrailItem, depTrailItem + ":jar:1.0" } );
278         final List patterns = Collections.singletonList( "otherGroup*" );
279 
280         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId, depTrail );
281 
282         mockManager.replayAll();
283 
284         final ArtifactFilter filter = createFilter( patterns, true );
285 
286         if ( !isInclusionExpected() )
287         {
288             assertFalse( filter.include( mac.artifact ) );
289         }
290         else
291         {
292             assertTrue( filter.include( mac.artifact ) );
293         }
294 
295         mockManager.verifyAll();
296     }
297 
298     public void testShouldNotIncludeWhenNegativeMatch()
299     {
300         final String groupId = "group";
301         final String artifactId = "artifact";
302 
303         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
304 
305         mockManager.replayAll();
306 
307         final List patterns = new ArrayList();
308 
309         patterns.add( "!group:artifact:jar" );
310 
311         final ArtifactFilter filter = createFilter( patterns );
312 
313         if ( !isInclusionExpected() )
314         {
315             assertTrue( filter.include( mac.artifact ) );
316         }
317         else
318         {
319             assertFalse( filter.include( mac.artifact ) );
320         }
321 
322         mockManager.verifyAll();
323     }
324 
325     public void testShouldIncludeWhenWildcardMatchesInsideSequence()
326     {
327         final String groupId = "group";
328         final String artifactId = "artifact";
329 
330         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
331 
332         mockManager.replayAll();
333 
334         final List patterns = new ArrayList();
335 
336         patterns.add( "group:*:jar" );
337 
338         final ArtifactFilter filter = createFilter( patterns );
339 
340         if ( !isInclusionExpected() )
341         {
342             assertFalse( filter.include( mac.artifact ) );
343         }
344         else
345         {
346             assertTrue( filter.include( mac.artifact ) );
347         }
348 
349         mockManager.verifyAll();
350     }
351 
352     public void testShouldIncludeWhenWildcardMatchesOutsideSequence()
353     {
354         final String groupId = "group";
355         final String artifactId = "artifact";
356 
357         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
358 
359         mockManager.replayAll();
360 
361         final List patterns = new ArrayList();
362 
363         patterns.add( "*:artifact:*" );
364 
365         final ArtifactFilter filter = createFilter( patterns );
366 
367         if ( !isInclusionExpected() )
368         {
369             assertFalse( filter.include( mac.artifact ) );
370         }
371         else
372         {
373             assertTrue( filter.include( mac.artifact ) );
374         }
375 
376         mockManager.verifyAll();
377     }
378 
379     public void testShouldIncludeWhenWildcardMatchesMiddleOfArtifactId()
380     {
381         final String groupId = "group";
382         final String artifactId = "some-artifact-id";
383 
384         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
385 
386         mockManager.replayAll();
387 
388         final List patterns = new ArrayList();
389 
390         patterns.add( "group:some-*-id" );
391 
392         final ArtifactFilter filter = createFilter( patterns );
393 
394         if ( !isInclusionExpected() )
395         {
396             assertFalse( filter.include( mac.artifact ) );
397         }
398         else
399         {
400             assertTrue( filter.include( mac.artifact ) );
401         }
402 
403         mockManager.verifyAll();
404     }
405 
406     public void testShouldIncludeWhenWildcardCoversPartOfGroupIdAndEverythingElse()
407     {
408         final String groupId = "some.group.id";
409         final String artifactId = "some-artifact-id";
410 
411         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId );
412 
413         mockManager.replayAll();
414 
415         final List patterns = new ArrayList();
416 
417         patterns.add( "some.group*" );
418 
419         final ArtifactFilter filter = createFilter( patterns );
420 
421         if ( !isInclusionExpected() )
422         {
423             assertFalse( filter.include( mac.artifact ) );
424         }
425         else
426         {
427             assertTrue( filter.include( mac.artifact ) );
428         }
429 
430         mockManager.verifyAll();
431     }
432 
433     public void testShouldIncludeTransitiveDependencyWhenWildcardMatchesButDoesntMatchParent()
434     {
435         final String groupId = "group";
436         final String artifactId = "artifact";
437 
438         final String otherGroup = "otherGroup";
439         final String otherArtifact = "otherArtifact";
440         final String otherType = "ejb";
441 
442         final String depTrailItem = otherGroup + ":" + otherArtifact + ":" + otherType + ":version";
443         final List depTrail = Collections.singletonList( depTrailItem );
444         final List patterns = Collections.singletonList( "*:jar:*" );
445 
446         final ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId, "jar", depTrail );
447         final ArtifactMockAndControl otherMac =
448             new ArtifactMockAndControl( otherGroup, otherArtifact, otherType, Collections.EMPTY_LIST );
449 
450         mockManager.replayAll();
451 
452         final ArtifactFilter filter = createFilter( patterns, true );
453 
454         if ( !isInclusionExpected() )
455         {
456             assertTrue( filter.include( otherMac.artifact ) );
457             assertFalse( filter.include( mac.artifact ) );
458         }
459         else
460         {
461             assertFalse( filter.include( otherMac.artifact ) );
462             assertTrue( filter.include( mac.artifact ) );
463         }
464 
465         mockManager.verifyAll();
466     }
467 
468     // FIXME: Not sure what this is even trying to test.
469     // public void testShouldIncludeDirectDependencyWhenInvertedWildcardMatchesButDoesntMatchTransitiveChild(
470     // boolean reverse )
471     // {
472     // String groupId = "group";
473     // String artifactId = "artifact";
474     //
475     // String otherGroup = "otherGroup";
476     // String otherArtifact = "otherArtifact";
477     // String otherType = "ejb";
478     //
479     // String depTrailItem = otherGroup + ":" + otherArtifact + ":" + otherType + ":version";
480     // List depTrail = Collections.singletonList( depTrailItem );
481     // List patterns = Collections.singletonList( "!*:ejb:*" );
482     //
483     // ArtifactMockAndControl mac = new ArtifactMockAndControl( groupId, artifactId, "jar", depTrail );
484     // ArtifactMockAndControl otherMac = new ArtifactMockAndControl( otherGroup, otherArtifact, otherType, null );
485     //
486     // mockManager.replayAll();
487     //
488     // ArtifactFilter filter = createFilter( patterns, true );
489     //
490     // if ( isInclusionExpected() )
491     // {
492     // assertTrue( filter.include( otherMac.artifact ) );
493     // assertFalse( filter.include( mac.artifact ) );
494     // }
495     // else
496     // {
497     // assertFalse( filter.include( otherMac.artifact ) );
498     // assertFalse( filter.include( mac.artifact ) );
499     // }
500     //
501     // mockManager.verifyAll();
502     // }
503 
504     private final class ArtifactMockAndControl
505     {
506         MockControl control;
507 
508         Artifact artifact;
509 
510         String groupId;
511 
512         String artifactId;
513 
514         String version;
515 
516         List dependencyTrail;
517 
518         String type;
519 
520         ArtifactMockAndControl( final String groupId, final String artifactId, final List depTrail )
521         {
522             this( groupId, artifactId, "jar", depTrail );
523         }
524 
525         ArtifactMockAndControl( final String groupId, final String artifactId, final String type,
526                                 final List dependencyTrail )
527         {
528             this.groupId = groupId;
529             this.artifactId = artifactId;
530             this.dependencyTrail = dependencyTrail;
531             this.type = type;
532 
533             control = MockControl.createControl( Artifact.class );
534             mockManager.add( control );
535 
536             artifact = (Artifact) control.getMock();
537 
538             enableGetDependencyConflictId();
539             enableGetGroupIdArtifactIdAndVersion();
540             enableGetId();
541 
542             if ( dependencyTrail != null )
543             {
544                 enableGetDependencyTrail();
545             }
546         }
547 
548         ArtifactMockAndControl( final String groupId, final String artifactId )
549         {
550             this( groupId, artifactId, "jar", null );
551         }
552 
553         void enableGetId()
554         {
555             artifact.getId();
556             control.setReturnValue( groupId + ":" + artifactId + ":" + type + ":version", MockControl.ZERO_OR_MORE );
557         }
558 
559         void enableGetDependencyTrail()
560         {
561             artifact.getDependencyTrail();
562             control.setReturnValue( dependencyTrail, MockControl.ZERO_OR_MORE );
563         }
564 
565         void enableGetDependencyConflictId()
566         {
567             artifact.getDependencyConflictId();
568             control.setReturnValue( groupId + ":" + artifactId + ":" + type, MockControl.ONE_OR_MORE );
569         }
570 
571         void enableGetGroupIdArtifactIdAndVersion()
572         {
573             artifact.getGroupId();
574             control.setReturnValue( groupId, MockControl.ONE_OR_MORE );
575 
576             artifact.getArtifactId();
577             control.setReturnValue( artifactId, MockControl.ONE_OR_MORE );
578 
579             artifact.getVersion();
580             control.setReturnValue( version, MockControl.ZERO_OR_MORE );
581 
582         }
583     }
584 
585 }