1 package org.apache.archiva.web.xmlrpc.services;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 import java.util.ArrayList;
24 import java.util.Date;
25 import java.util.List;
26
27 import org.apache.archiva.indexer.search.RepositorySearch;
28 import org.apache.archiva.indexer.search.SearchResultHit;
29 import org.apache.archiva.indexer.search.SearchResultLimits;
30 import org.apache.archiva.indexer.search.SearchResults;
31 import org.apache.archiva.indexer.util.SearchUtil;
32 import org.apache.archiva.web.xmlrpc.api.SearchService;
33 import org.apache.archiva.web.xmlrpc.api.beans.Artifact;
34 import org.apache.archiva.web.xmlrpc.api.beans.Dependency;
35 import org.apache.archiva.web.xmlrpc.security.XmlRpcUserRepositories;
36 import org.apache.maven.archiva.database.ArchivaDAO;
37 import org.apache.maven.archiva.database.ArchivaDatabaseException;
38 import org.apache.maven.archiva.database.ArtifactDAO;
39 import org.apache.maven.archiva.database.ObjectNotFoundException;
40 import org.apache.maven.archiva.database.browsing.BrowsingResults;
41 import org.apache.maven.archiva.database.browsing.RepositoryBrowsing;
42 import org.apache.maven.archiva.database.constraints.ArtifactsByChecksumConstraint;
43 import org.apache.maven.archiva.database.constraints.UniqueVersionConstraint;
44 import org.apache.maven.archiva.model.ArchivaArtifact;
45 import org.apache.maven.archiva.model.ArchivaProjectModel;
46 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
47 import org.easymock.MockControl;
48 import org.easymock.classextension.MockClassControl;
49 import org.slf4j.Logger;
50
51
52
53
54
55
56 public class SearchServiceImplTest
57 extends PlexusInSpringTestCase
58 {
59 private SearchService searchService;
60
61 private MockControl userReposControl;
62
63 private XmlRpcUserRepositories userRepos;
64
65 private MockControl searchControl;
66
67 private RepositorySearch search;
68
69 private MockControl archivaDAOControl;
70
71 private ArchivaDAO archivaDAO;
72
73 private MockControl artifactDAOControl;
74
75 private ArtifactDAO artifactDAO;
76
77 private MockControl repoBrowsingControl;
78
79 private RepositoryBrowsing repoBrowsing;
80
81 private MockControl loggerControl;
82
83 private Logger logger;
84
85 private static final String ARCHIVA_TEST_ARTIFACT_ID = "archiva-xmlrpc-test";
86
87 private static final String ARCHIVA_TEST_GROUP_ID = "org.apache.archiva";
88
89 @Override
90 public void setUp()
91 throws Exception
92 {
93 userReposControl = MockClassControl.createControl( XmlRpcUserRepositories.class );
94 userRepos = ( XmlRpcUserRepositories ) userReposControl.getMock();
95
96 archivaDAOControl = MockControl.createControl( ArchivaDAO.class );
97 archivaDAOControl.setDefaultMatcher( MockControl.ALWAYS_MATCHER );
98 archivaDAO = ( ArchivaDAO ) archivaDAOControl.getMock();
99
100 repoBrowsingControl = MockControl.createControl( RepositoryBrowsing.class );
101 repoBrowsing = ( RepositoryBrowsing ) repoBrowsingControl.getMock();
102
103 searchControl = MockControl.createControl( RepositorySearch.class );
104 searchControl.setDefaultMatcher( MockControl.ALWAYS_MATCHER );
105 search = ( RepositorySearch ) searchControl.getMock();
106
107 searchService = new SearchServiceImpl( userRepos, archivaDAO, repoBrowsing, search );
108
109 artifactDAOControl = MockControl.createControl( ArtifactDAO.class );
110 artifactDAO = ( ArtifactDAO ) artifactDAOControl.getMock();
111
112 loggerControl = MockControl.createControl( Logger.class );
113 logger = ( Logger ) loggerControl.getMock();
114
115 }
116
117
118 public void testQuickSearchModelPackagingIsUsed()
119 throws Exception
120 {
121 List<String> observableRepoIds = new ArrayList<String>();
122 observableRepoIds.add( "repo1.mirror" );
123 observableRepoIds.add( "public.releases" );
124
125 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
126
127 SearchResults results = new SearchResults();
128 List<String> versions = new ArrayList<String>();
129 versions.add( "1.0" );
130
131 SearchResultHit resultHit = new SearchResultHit();
132 resultHit.setGroupId( ARCHIVA_TEST_GROUP_ID );
133 resultHit.setArtifactId( "archiva-webapp" );
134 resultHit.setVersions( versions );
135 resultHit.setRepositoryId( null );
136
137 results.addHit( SearchUtil.getHitId( ARCHIVA_TEST_GROUP_ID, "archiva-webapp" ), resultHit );
138
139 SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
140
141 searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ), results );
142
143 archivaDAOControl.expectAndReturn( archivaDAO.query( new UniqueVersionConstraint( observableRepoIds, resultHit.getGroupId(),
144 resultHit.getArtifactId() ) ), null );
145
146 ArchivaProjectModel model = new ArchivaProjectModel();
147 model.setGroupId( ARCHIVA_TEST_GROUP_ID );
148 model.setArtifactId( "archiva-webapp" );
149 model.setVersion( "1.0" );
150 model.setPackaging( "war" );
151
152 repoBrowsingControl.expectAndReturn( repoBrowsing.selectVersion( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID, "archiva-webapp", "1.0" ), model );
153
154 repoBrowsingControl.expectAndReturn( repoBrowsing.getRepositoryId( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID, "archiva-webapp", "1.0" ), "repo1.mirror" );
155
156 userReposControl.replay();
157 searchControl.replay();
158 repoBrowsingControl.replay();
159 archivaDAOControl.replay();
160
161 List<Artifact> artifacts = searchService.quickSearch( "archiva" );
162
163 userReposControl.verify();
164 searchControl.verify();
165 repoBrowsingControl.verify();
166 archivaDAOControl.verify();
167
168 assertNotNull( artifacts );
169 assertEquals( 1, artifacts.size() );
170
171 Artifact artifact = artifacts.get( 0 );
172 assertEquals( ARCHIVA_TEST_GROUP_ID, artifact.getGroupId() );
173 assertEquals( "archiva-webapp", artifact.getArtifactId() );
174 assertEquals( "1.0", artifact.getVersion() );
175 assertEquals( "war", artifact.getType() );
176 assertNotNull( "Repository should not be null!", artifact.getRepositoryId() );
177 assertEquals( "repo1.mirror", artifact.getRepositoryId() );
178 }
179
180
181 public void testQuickSearchDefaultPackagingIsUsed()
182 throws Exception
183 {
184 List<String> observableRepoIds = new ArrayList<String>();
185 observableRepoIds.add( "repo1.mirror" );
186 observableRepoIds.add( "public.releases" );
187
188 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
189
190 SearchResults results = new SearchResults();
191 List<String> versions = new ArrayList<String>();
192 versions.add( "1.0" );
193
194 SearchResultHit resultHit = new SearchResultHit();
195 resultHit.setRepositoryId( null );
196 resultHit.setGroupId( ARCHIVA_TEST_GROUP_ID );
197 resultHit.setArtifactId( ARCHIVA_TEST_ARTIFACT_ID );
198 resultHit.setVersions( versions );
199
200 results.addHit( SearchUtil.getHitId( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID ), resultHit );
201
202 SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
203
204 searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ), results );
205
206 archivaDAOControl.expectAndReturn( archivaDAO.query( new UniqueVersionConstraint( observableRepoIds, resultHit.getGroupId(),
207 resultHit.getArtifactId() ) ), null );
208
209 repoBrowsingControl.expectAndReturn( repoBrowsing.selectVersion( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID,
210 ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), null );
211
212 repoBrowsingControl.expectAndReturn( repoBrowsing.getRepositoryId( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID,
213 ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), null );
214
215 userReposControl.replay();
216 searchControl.replay();
217 repoBrowsingControl.replay();
218 archivaDAOControl.replay();
219
220 List<Artifact> artifacts = searchService.quickSearch( "archiva" );
221
222 userReposControl.verify();
223 searchControl.verify();
224 repoBrowsingControl.verify();
225 archivaDAOControl.verify();
226
227 assertNotNull( artifacts );
228 assertEquals( 1, artifacts.size() );
229
230 Artifact artifact = artifacts.get( 0 );
231 assertEquals( ARCHIVA_TEST_GROUP_ID, artifact.getGroupId() );
232 assertEquals( ARCHIVA_TEST_ARTIFACT_ID, artifact.getArtifactId() );
233 assertEquals( "1.0", artifact.getVersion() );
234 assertEquals( "jar", artifact.getType() );
235 assertNull( "Repository should be null since the model was not found in the database!", artifact.getRepositoryId() );
236 }
237
238 public void testQuickSearchArtifactObjectNotFoundException()
239 throws Exception
240 {
241 List<String> observableRepoIds = new ArrayList<String>();
242 observableRepoIds.add( "repo1.mirror" );
243
244 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
245
246 SearchResults results = new SearchResults();
247 List<String> versions = new ArrayList<String>();
248 versions.add( "1.0" );
249
250 SearchResultHit resultHit = new SearchResultHit();
251 resultHit.setRepositoryId( "repo1.mirror" );
252 resultHit.setGroupId( "org.apache.archiva" );
253 resultHit.setArtifactId( "archiva-test" );
254 resultHit.setVersions( versions );
255
256 results.addHit( SearchUtil.getHitId( "org.apache.archiva", "archiva-test" ), resultHit );
257
258 SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
259
260 searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ), results );
261
262 archivaDAOControl.expectAndReturn( archivaDAO.query( new UniqueVersionConstraint( observableRepoIds, resultHit.getGroupId(),
263 resultHit.getArtifactId() ) ), null );
264
265 ObjectNotFoundException exception = new ObjectNotFoundException( "org.apache.archiva.archiva-test:1.0" );
266
267 repoBrowsingControl.expectAndThrow( repoBrowsing.selectVersion( "", observableRepoIds, "org.apache.archiva", "archiva-test", "1.0" ), exception );
268
269 logger.debug( "Unable to find pom artifact : " + exception.getMessage() );
270 loggerControl.setDefaultVoidCallable();
271
272 userReposControl.replay();
273 searchControl.replay();
274 repoBrowsingControl.replay();
275 archivaDAOControl.replay();
276 loggerControl.replay();
277
278 List<Artifact> artifacts = searchService.quickSearch( "archiva" );
279
280 userReposControl.verify();
281 searchControl.verify();
282 repoBrowsingControl.verify();
283 archivaDAOControl.verify();
284 loggerControl.verify();
285
286 assertNotNull( artifacts );
287 assertEquals( 0, artifacts.size() );
288 }
289
290 public void testQuickSearchArtifactArchivaDatabaseException()
291 throws Exception
292 {
293 List<String> observableRepoIds = new ArrayList<String>();
294 observableRepoIds.add( "repo1.mirror" );
295
296 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
297
298 SearchResults results = new SearchResults();
299 List<String> versions = new ArrayList<String>();
300 versions.add( "1.0" );
301
302 SearchResultHit resultHit = new SearchResultHit();
303 resultHit.setRepositoryId( "repo1.mirror" );
304 resultHit.setGroupId( "org.apache.archiva" );
305 resultHit.setArtifactId( "archiva-test" );
306 resultHit.setVersions( versions );
307
308 results.addHit( SearchUtil.getHitId( "org.apache.archiva", "archiva-test" ), resultHit );
309
310 SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
311
312 searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ), results );
313
314 archivaDAOControl.expectAndReturn( archivaDAO.query( new UniqueVersionConstraint( observableRepoIds, resultHit.getGroupId(),
315 resultHit.getArtifactId() ) ), null );
316
317 ArchivaDatabaseException exception = new ArchivaDatabaseException( "org.apache.archiva.archiva-test:1.0" );
318
319 repoBrowsingControl.expectAndThrow( repoBrowsing.selectVersion( "", observableRepoIds, "org.apache.archiva", "archiva-test", "1.0" ), exception );
320
321 logger.debug( "Error occurred while getting pom artifact from database : " + exception.getMessage() );
322 loggerControl.setDefaultVoidCallable();
323
324 userReposControl.replay();
325 searchControl.replay();
326 repoBrowsingControl.replay();
327 archivaDAOControl.replay();
328 loggerControl.replay();
329
330 List<Artifact> artifacts = searchService.quickSearch( "archiva" );
331
332 userReposControl.verify();
333 searchControl.verify();
334 repoBrowsingControl.verify();
335 archivaDAOControl.verify();
336 loggerControl.verify();
337
338 assertNotNull( artifacts );
339 assertEquals( 0, artifacts.size() );
340 }
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401 public void testQuickSearchArtifactRegularSearch()
402 throws Exception
403 {
404 List<String> observableRepoIds = new ArrayList<String>();
405 observableRepoIds.add( "repo1.mirror" );
406 observableRepoIds.add( "public.releases" );
407
408 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
409
410 SearchResults results = new SearchResults();
411 List<String> versions = new ArrayList<String>();
412 versions.add( "1.0" );
413
414 SearchResultHit resultHit = new SearchResultHit();
415 resultHit.setGroupId( ARCHIVA_TEST_GROUP_ID );
416 resultHit.setArtifactId( ARCHIVA_TEST_ARTIFACT_ID );
417 resultHit.setVersions( versions );
418 resultHit.setRepositoryId( null );
419
420 results.addHit( SearchUtil.getHitId( resultHit.getGroupId(), resultHit.getArtifactId() ), resultHit );
421
422 archivaDAOControl.expectAndReturn( archivaDAO.query( new UniqueVersionConstraint( observableRepoIds, resultHit.getGroupId(),
423 resultHit.getArtifactId() ) ), null );
424
425 SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
426
427 searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ), results );
428
429 ArchivaProjectModel model = new ArchivaProjectModel();
430 model.setGroupId( ARCHIVA_TEST_GROUP_ID );
431 model.setArtifactId( ARCHIVA_TEST_ARTIFACT_ID );
432 model.setVersion( "1.0" );
433 model.setPackaging( "jar" );
434
435 repoBrowsingControl.expectAndReturn( repoBrowsing.selectVersion( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID,
436 ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), model );
437
438 repoBrowsingControl.expectAndReturn( repoBrowsing.getRepositoryId( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID,
439 ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), "repo1.mirror" );
440
441 userReposControl.replay();
442 searchControl.replay();
443 archivaDAOControl.replay();
444 repoBrowsingControl.replay();
445
446 List<Artifact> artifacts = searchService.quickSearch( "archiva" );
447
448 userReposControl.verify();
449 searchControl.verify();
450 archivaDAOControl.verify();
451 repoBrowsingControl.verify();
452
453 assertNotNull( artifacts );
454 assertEquals( 1, artifacts.size() );
455
456 Artifact artifact = artifacts.get( 0 );
457 assertEquals( ARCHIVA_TEST_GROUP_ID, artifact.getGroupId() );
458 assertEquals( ARCHIVA_TEST_ARTIFACT_ID, artifact.getArtifactId() );
459 assertEquals( "1.0", artifact.getVersion() );
460 assertEquals( "jar", artifact.getType() );
461 assertNotNull( "Repository should not be null!", artifact.getRepositoryId() );
462 assertEquals( "repo1.mirror", artifact.getRepositoryId() );
463 }
464
465 public void testQuickSearchNoResults( )
466 throws Exception
467 {
468 List<String> observableRepoIds = new ArrayList<String>();
469 observableRepoIds.add( "repo1.mirror" );
470 observableRepoIds.add( "public.releases" );
471
472 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
473
474 SearchResults results = new SearchResults();
475 SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
476
477 searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "non-existent", limits, null ), results );
478 userReposControl.replay();
479 searchControl.replay();
480
481 List<Artifact> artifacts = searchService.quickSearch( "test" );
482
483 userReposControl.verify();
484 searchControl.verify();
485
486 assertNotNull( artifacts );
487 assertEquals( 0, artifacts.size() );
488 }
489
490
491
492 public void testGetArtifactByChecksum()
493 throws Exception
494 {
495 Date whenGathered = new Date();
496
497 ArtifactsByChecksumConstraint constraint = new ArtifactsByChecksumConstraint( "a1b2c3aksjhdasfkdasasd" );
498 List<ArchivaArtifact> artifacts = new ArrayList<ArchivaArtifact>();
499 ArchivaArtifact artifact = new ArchivaArtifact( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0", "", "jar", "test-repo" );
500 artifact.getModel().setWhenGathered( whenGathered );
501 artifacts.add( artifact );
502
503 archivaDAOControl.expectAndReturn( archivaDAO.getArtifactDAO(), artifactDAO );
504 artifactDAO.queryArtifacts( constraint );
505 artifactDAOControl.setMatcher( MockControl.ALWAYS_MATCHER );
506 artifactDAOControl.setReturnValue( artifacts );
507
508 archivaDAOControl.replay();
509 artifactDAOControl.replay();
510
511 List<Artifact> results = searchService.getArtifactByChecksum( "a1b2c3aksjhdasfkdasasd" );
512
513 archivaDAOControl.verify();
514 artifactDAOControl.verify();
515
516 assertNotNull( results );
517 assertEquals( 1, results.size() );
518 }
519
520
521
522 public void testGetArtifactVersionsArtifactExists()
523 throws Exception
524 {
525 Date whenGathered = new Date();
526
527 List<String> observableRepoIds = new ArrayList<String>();
528 observableRepoIds.add( "repo1.mirror" );
529 observableRepoIds.add( "public.releases" );
530
531 List<String> versions = new ArrayList<String>();
532 versions.add( "1.0" );
533 versions.add( "1.1-beta-1" );
534 versions.add( "1.1-beta-2" );
535 versions.add( "1.1" );
536 versions.add( "1.2" );
537 versions.add( "1.2.1-SNAPSHOT" );
538
539 BrowsingResults results = new BrowsingResults( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID );
540 results.setSelectedRepositoryIds( observableRepoIds );
541 results.setVersions( versions );
542
543 List<ArchivaArtifact> archivaArtifacts = new ArrayList<ArchivaArtifact>();
544 ArchivaArtifact archivaArtifact = new ArchivaArtifact( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, versions.get( 0 ), "", "pom", "repo1.mirror" );
545 archivaArtifact.getModel().setWhenGathered( whenGathered );
546 archivaArtifacts.add( archivaArtifact );
547
548 archivaArtifact = new ArchivaArtifact( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, versions.get( 1 ), "", "pom", "public.releases" );
549 archivaArtifact.getModel().setWhenGathered( whenGathered );
550 archivaArtifacts.add( archivaArtifact );
551
552 archivaArtifact = new ArchivaArtifact( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, versions.get( 2 ), "", "pom", "repo1.mirror" );
553 archivaArtifact.getModel().setWhenGathered( whenGathered );
554 archivaArtifacts.add( archivaArtifact );
555
556 archivaArtifact = new ArchivaArtifact( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, versions.get( 3 ), "", "pom", "public.releases" );
557 archivaArtifact.getModel().setWhenGathered( whenGathered );
558 archivaArtifacts.add( archivaArtifact );
559
560 archivaArtifact = new ArchivaArtifact( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, versions.get( 4 ), "", "pom", "repo1.mirror" );
561 archivaArtifact.getModel().setWhenGathered( whenGathered );
562 archivaArtifacts.add( archivaArtifact );
563
564 archivaArtifact = new ArchivaArtifact( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, versions.get( 5 ), "", "pom", "public.releases" );
565 archivaArtifact.getModel().setWhenGathered( whenGathered );
566 archivaArtifacts.add( archivaArtifact );
567
568 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
569 repoBrowsingControl.expectAndReturn( repoBrowsing.selectArtifactId( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID,
570 ARCHIVA_TEST_ARTIFACT_ID ), results );
571 archivaDAOControl.expectAndReturn( archivaDAO.getArtifactDAO(), artifactDAO );
572
573 artifactDAOControl.expectAndDefaultReturn( artifactDAO.getArtifact( ARCHIVA_TEST_GROUP_ID,
574 ARCHIVA_TEST_ARTIFACT_ID, versions.get( 0 ), "", "pom", "repo1.mirror" ), archivaArtifacts.get( 0 ) );
575 artifactDAOControl.expectAndDefaultReturn( artifactDAO.getArtifact( ARCHIVA_TEST_GROUP_ID,
576 ARCHIVA_TEST_ARTIFACT_ID, versions.get( 1 ), "", "pom", "public.releases" ), archivaArtifacts.get( 1 ) );
577 artifactDAOControl.expectAndDefaultReturn( artifactDAO.getArtifact( ARCHIVA_TEST_GROUP_ID,
578 ARCHIVA_TEST_ARTIFACT_ID, versions.get( 2 ), "", "pom", "repo1.mirror" ), archivaArtifacts.get( 2 ) );
579 artifactDAOControl.expectAndDefaultReturn( artifactDAO.getArtifact( ARCHIVA_TEST_GROUP_ID,
580 ARCHIVA_TEST_ARTIFACT_ID, versions.get( 3 ), "", "pom", "public.releases" ), archivaArtifacts.get( 3 ) );
581 artifactDAOControl.expectAndDefaultReturn( artifactDAO.getArtifact( ARCHIVA_TEST_GROUP_ID,
582 ARCHIVA_TEST_ARTIFACT_ID, versions.get( 4 ), "", "pom", "repo1.mirror" ), archivaArtifacts.get( 4 ) );
583 artifactDAOControl.expectAndDefaultReturn( artifactDAO.getArtifact( ARCHIVA_TEST_GROUP_ID,
584 ARCHIVA_TEST_ARTIFACT_ID, versions.get( 5 ), "", "pom", "public.releases" ), archivaArtifacts.get( 5 ) );
585
586 userReposControl.replay();
587 repoBrowsingControl.replay();
588 artifactDAOControl.replay();
589
590 List<Artifact> artifacts = searchService.getArtifactVersions( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID );
591
592 userReposControl.verify();
593 repoBrowsingControl.verify();
594 artifactDAOControl.verify();
595
596 assertNotNull( artifacts );
597 assertEquals( 6, artifacts.size() );
598 }
599
600
601
602 public void testGetArtifactVersionsByDateArtifactExists()
603 throws Exception
604 {
605
606 }
607
608 public void testGetArtifactVersionsByDateArtifactDoesNotExist()
609 throws Exception
610 {
611
612 }
613
614
615
616 public void testGetDependenciesArtifactExists()
617 throws Exception
618 {
619 List<String> observableRepoIds = new ArrayList<String>();
620 observableRepoIds.add( "repo1.mirror" );
621 observableRepoIds.add( "public.releases" );
622
623 ArchivaProjectModel model = new ArchivaProjectModel();
624 model.setGroupId( ARCHIVA_TEST_GROUP_ID );
625 model.setArtifactId( ARCHIVA_TEST_ARTIFACT_ID );
626 model.setVersion( "1.0" );
627
628 org.apache.maven.archiva.model.Dependency dependency = new org.apache.maven.archiva.model.Dependency();
629 dependency.setGroupId( "commons-logging" );
630 dependency.setArtifactId( "commons-logging" );
631 dependency.setVersion( "2.0" );
632
633 model.addDependency( dependency );
634
635 dependency = new org.apache.maven.archiva.model.Dependency();
636 dependency.setGroupId( "junit" );
637 dependency.setArtifactId( "junit" );
638 dependency.setVersion( "2.4" );
639 dependency.setScope( "test" );
640
641 model.addDependency( dependency );
642
643 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
644 repoBrowsingControl.expectAndReturn(
645 repoBrowsing.selectVersion( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), model );
646
647 repoBrowsingControl.replay();
648 userReposControl.replay();
649
650 List<Dependency> dependencies = searchService.getDependencies( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" );
651
652 repoBrowsingControl.verify();
653 userReposControl.verify();
654
655 assertNotNull( dependencies );
656 assertEquals( 2, dependencies.size() );
657 }
658
659 public void testGetDependenciesArtifactDoesNotExist()
660 throws Exception
661 {
662 List<String> observableRepoIds = new ArrayList<String>();
663 observableRepoIds.add( "repo1.mirror" );
664 observableRepoIds.add( "public.releases" );
665
666 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
667 repoBrowsingControl.expectAndThrow(
668 repoBrowsing.selectVersion( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), new ObjectNotFoundException( "Artifact does not exist." ) );
669
670 userReposControl.replay();
671 repoBrowsingControl.replay();
672
673 try
674 {
675 searchService.getDependencies( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" );
676 fail( "An exception should have been thrown." );
677 }
678 catch ( Exception e )
679 {
680 assertEquals( "Artifact does not exist.", e.getMessage() );
681 }
682
683 userReposControl.verify();
684 repoBrowsingControl.verify();
685 }
686
687 public void testGetDependencyTreeArtifactExists()
688 throws Exception
689 {
690
691 }
692
693 public void testGetDependencyTreeArtifactDoesNotExist()
694 throws Exception
695 {
696
697 }
698
699 public void testGetDependees()
700 throws Exception
701 {
702 Date date = new Date();
703 List<String> observableRepoIds = new ArrayList<String>();
704 observableRepoIds.add( "repo1.mirror" );
705 observableRepoIds.add( "public.releases" );
706
707 List<ArchivaProjectModel> dependeeModels = new ArrayList<ArchivaProjectModel>();
708 ArchivaProjectModel dependeeModel = new ArchivaProjectModel();
709 dependeeModel.setGroupId( ARCHIVA_TEST_GROUP_ID );
710 dependeeModel.setArtifactId( "archiva-dependee-one" );
711 dependeeModel.setVersion( "1.0" );
712 dependeeModel.setWhenIndexed( date );
713 dependeeModels.add( dependeeModel );
714
715 dependeeModel = new ArchivaProjectModel();
716 dependeeModel.setGroupId( ARCHIVA_TEST_GROUP_ID );
717 dependeeModel.setArtifactId( "archiva-dependee-two" );
718 dependeeModel.setVersion( "1.0" );
719 dependeeModel.setWhenIndexed( date );
720 dependeeModels.add( dependeeModel );
721
722 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
723 repoBrowsingControl.expectAndReturn( repoBrowsing.getUsedBy( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID,
724 ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), dependeeModels );
725
726 repoBrowsingControl.replay();
727 userReposControl.replay();
728
729 List<Artifact> dependees = searchService.getDependees( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" );
730
731 repoBrowsingControl.verify();
732 userReposControl.verify();
733
734 assertNotNull( dependees );
735 assertEquals( 2, dependees.size() );
736 }
737
738 public void testGetDependeesArtifactDoesNotExist()
739 throws Exception
740 {
741 Date date = new Date();
742 List<String> observableRepoIds = new ArrayList<String>();
743 observableRepoIds.add( "repo1.mirror" );
744 observableRepoIds.add( "public.releases" );
745
746 List dependeeModels = new ArrayList();
747 ArchivaProjectModel dependeeModel = new ArchivaProjectModel();
748 dependeeModel.setGroupId( ARCHIVA_TEST_GROUP_ID );
749 dependeeModel.setArtifactId( "archiva-dependee-one" );
750 dependeeModel.setVersion( "1.0" );
751 dependeeModel.setWhenIndexed( date );
752 dependeeModels.add( dependeeModel );
753
754 dependeeModel = new ArchivaProjectModel();
755 dependeeModel.setGroupId( ARCHIVA_TEST_GROUP_ID );
756 dependeeModel.setArtifactId( "archiva-dependee-two" );
757 dependeeModel.setVersion( "1.0" );
758 dependeeModel.setWhenIndexed( date );
759 dependeeModels.add( dependeeModel );
760
761 userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
762 repoBrowsingControl.expectAndReturn( repoBrowsing.getUsedBy( "", observableRepoIds, ARCHIVA_TEST_GROUP_ID,
763 ARCHIVA_TEST_ARTIFACT_ID, "1.0" ), null );
764
765 repoBrowsingControl.replay();
766 userReposControl.replay();
767
768 try
769 {
770 List<Artifact> dependees = searchService.getDependees( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" );
771 fail( "An exception should have been thrown." );
772 }
773 catch ( Exception e )
774 {
775 repoBrowsingControl.verify();
776 userReposControl.verify();
777 }
778 }
779 }