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 import java.io.File;
23 import java.io.IOException;
24 import java.util.ArrayList;
25 import java.util.Collections;
26 import java.util.List;
27
28 import org.apache.archiva.web.xmlrpc.api.beans.ManagedRepository;
29 import org.apache.archiva.web.xmlrpc.api.beans.RemoteRepository;
30 import org.apache.commons.io.FileUtils;
31 import org.apache.commons.io.filefilter.FileFilterUtils;
32 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
33 import org.apache.maven.archiva.configuration.Configuration;
34 import org.apache.maven.archiva.configuration.DatabaseScanningConfiguration;
35 import org.apache.maven.archiva.configuration.FileTypes;
36 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
37 import org.apache.maven.archiva.configuration.RemoteRepositoryConfiguration;
38 import org.apache.maven.archiva.configuration.RepositoryScanningConfiguration;
39 import org.apache.maven.archiva.consumers.InvalidRepositoryContentConsumer;
40 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
41 import org.apache.maven.archiva.database.ArtifactDAO;
42 import org.apache.maven.archiva.database.updater.DatabaseCleanupConsumer;
43 import org.apache.maven.archiva.database.updater.DatabaseConsumers;
44 import org.apache.maven.archiva.database.updater.DatabaseUnprocessedArtifactConsumer;
45 import org.apache.maven.archiva.model.ArchivaArtifact;
46 import org.apache.maven.archiva.model.ArchivaArtifactModel;
47 import org.apache.maven.archiva.model.ArtifactReference;
48 import org.apache.maven.archiva.repository.RepositoryContentFactory;
49 import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent;
50 import org.apache.maven.archiva.repository.content.ManagedLegacyRepositoryContent;
51 import org.apache.maven.archiva.repository.content.PathParser;
52 import org.apache.maven.archiva.repository.events.RepositoryListener;
53 import org.apache.maven.archiva.repository.layout.LayoutException;
54 import org.apache.maven.archiva.repository.scanner.RepositoryContentConsumers;
55 import org.apache.maven.archiva.scheduled.ArchivaTaskScheduler;
56 import org.apache.maven.archiva.scheduled.tasks.DatabaseTask;
57 import org.apache.maven.archiva.scheduled.tasks.RepositoryTask;
58 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
59 import org.easymock.MockControl;
60 import org.easymock.classextension.MockClassControl;
61
62
63
64
65
66
67 public class AdministrationServiceImplTest
68 extends PlexusInSpringTestCase
69 {
70 private MockControl archivaConfigControl;
71
72 private ArchivaConfiguration archivaConfig;
73
74 private MockControl configControl;
75
76 private Configuration config;
77
78 private AdministrationServiceImpl service;
79
80 private MockControl taskSchedulerControl;
81
82 private ArchivaTaskScheduler taskScheduler;
83
84
85 private MockControl repoConsumerUtilsControl;
86
87 private RepositoryContentConsumers repoConsumersUtil;
88
89 private MockControl knownContentConsumerControl;
90
91 private MockControl invalidContentConsumerControl;
92
93 private KnownRepositoryContentConsumer indexArtifactConsumer;
94
95 private KnownRepositoryContentConsumer indexPomConsumer;
96
97 private InvalidRepositoryContentConsumer checkPomConsumer;
98
99 private InvalidRepositoryContentConsumer checkMetadataConsumer;
100
101
102 private MockControl dbConsumersUtilControl;
103
104 private DatabaseConsumers dbConsumersUtil;
105
106 private MockControl unprocessedConsumersControl;
107
108 private DatabaseUnprocessedArtifactConsumer processArtifactConsumer;
109
110 private DatabaseUnprocessedArtifactConsumer processPomConsumer;
111
112
113 private MockControl repoFactoryControl;
114
115 private RepositoryContentFactory repositoryFactory;
116
117 private MockControl artifactDaoControl;
118
119 private ArtifactDAO artifactDao;
120
121 private MockControl listenerControl;
122
123 private RepositoryListener listener;
124
125 private DatabaseCleanupConsumer cleanupIndexConsumer;
126
127 private DatabaseCleanupConsumer cleanupDbConsumer;
128
129 private MockControl cleanupConsumersControl;
130
131 protected void setUp()
132 throws Exception
133 {
134 super.setUp();
135
136 archivaConfigControl = MockControl.createControl( ArchivaConfiguration.class );
137 archivaConfig = ( ArchivaConfiguration ) archivaConfigControl.getMock();
138
139 configControl = MockClassControl.createControl( Configuration.class );
140 config = ( Configuration ) configControl.getMock();
141
142 taskSchedulerControl = MockControl.createControl( ArchivaTaskScheduler.class );
143 taskScheduler = ( ArchivaTaskScheduler ) taskSchedulerControl.getMock();
144
145
146 repoConsumerUtilsControl = MockClassControl.createControl( RepositoryContentConsumers.class );
147 repoConsumersUtil = ( RepositoryContentConsumers ) repoConsumerUtilsControl.getMock();
148
149 knownContentConsumerControl = MockControl.createControl( KnownRepositoryContentConsumer.class );
150 indexArtifactConsumer = ( KnownRepositoryContentConsumer ) knownContentConsumerControl.getMock();
151 indexPomConsumer = ( KnownRepositoryContentConsumer ) knownContentConsumerControl.getMock();
152
153 invalidContentConsumerControl = MockControl.createControl( InvalidRepositoryContentConsumer.class );
154 checkPomConsumer = ( InvalidRepositoryContentConsumer ) invalidContentConsumerControl.getMock();
155 checkMetadataConsumer = ( InvalidRepositoryContentConsumer ) invalidContentConsumerControl.getMock();
156
157
158 dbConsumersUtilControl = MockClassControl.createControl( DatabaseConsumers.class );
159 dbConsumersUtil = ( DatabaseConsumers ) dbConsumersUtilControl.getMock();
160
161 cleanupConsumersControl = MockControl.createControl( DatabaseCleanupConsumer.class );
162 cleanupIndexConsumer = (DatabaseCleanupConsumer) cleanupConsumersControl.getMock();
163 cleanupDbConsumer = (DatabaseCleanupConsumer) cleanupConsumersControl.getMock();
164
165 unprocessedConsumersControl = MockControl.createControl( DatabaseUnprocessedArtifactConsumer.class );
166 processArtifactConsumer = ( DatabaseUnprocessedArtifactConsumer ) unprocessedConsumersControl.getMock();
167 processPomConsumer = ( DatabaseUnprocessedArtifactConsumer ) unprocessedConsumersControl.getMock();
168
169
170 repoFactoryControl = MockClassControl.createControl( RepositoryContentFactory.class );
171 repositoryFactory = ( RepositoryContentFactory ) repoFactoryControl.getMock();
172
173 artifactDaoControl = MockControl.createControl( ArtifactDAO.class );
174 artifactDao = ( ArtifactDAO ) artifactDaoControl.getMock();
175
176 listenerControl = MockControl.createControl( RepositoryListener.class );
177 listener = (RepositoryListener) listenerControl.getMock();
178
179 service =
180 new AdministrationServiceImpl( archivaConfig, repoConsumersUtil, dbConsumersUtil, repositoryFactory,
181 artifactDao, taskScheduler, Collections.singletonList( listener ) );
182 }
183
184
185
186 public void testGetAllDbConsumers()
187 throws Exception
188 {
189 recordDbConsumers();
190
191 dbConsumersUtilControl.replay();
192 cleanupConsumersControl.replay();
193 unprocessedConsumersControl.replay();
194
195 List<String> dbConsumers = service.getAllDatabaseConsumers();
196
197 dbConsumersUtilControl.verify();
198 cleanupConsumersControl.verify();
199 unprocessedConsumersControl.verify();
200
201 assertNotNull( dbConsumers );
202 assertEquals( 4, dbConsumers.size() );
203 assertTrue( dbConsumers.contains( "cleanup-index" ) );
204 assertTrue( dbConsumers.contains( "cleanup-database" ) );
205 assertTrue( dbConsumers.contains( "process-artifact" ) );
206 assertTrue( dbConsumers.contains( "process-pom" ) );
207 }
208
209 public void testConfigureValidDatabaseConsumer()
210 throws Exception
211 {
212 DatabaseScanningConfiguration dbScanning = new DatabaseScanningConfiguration();
213 dbScanning.addCleanupConsumer( "cleanup-index" );
214 dbScanning.addCleanupConsumer( "cleanup-database" );
215 dbScanning.addUnprocessedConsumer( "process-artifact" );
216
217 recordDbConsumers();
218
219
220 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
221 configControl.expectAndReturn( config.getDatabaseScanning(), dbScanning );
222
223 config.setDatabaseScanning( dbScanning );
224 configControl.setMatcher( MockControl.ALWAYS_MATCHER );
225 configControl.setVoidCallable();
226
227 archivaConfig.save( config );
228 archivaConfigControl.setVoidCallable();
229
230 dbConsumersUtilControl.replay();
231 cleanupConsumersControl.replay();
232 unprocessedConsumersControl.replay();
233 archivaConfigControl.replay();
234 configControl.replay();
235
236 try
237 {
238 boolean success = service.configureDatabaseConsumer( "process-pom", true );
239 assertTrue( success );
240 }
241 catch ( Exception e )
242 {
243 fail( "An exception should not have been thrown." );
244 }
245
246 dbConsumersUtilControl.verify();
247 cleanupConsumersControl.verify();
248 unprocessedConsumersControl.verify();
249 archivaConfigControl.verify();
250 configControl.verify();
251
252
253 dbConsumersUtilControl.reset();
254 cleanupConsumersControl.reset();
255 unprocessedConsumersControl.reset();
256 archivaConfigControl.reset();
257 configControl.reset();
258
259 dbScanning.addUnprocessedConsumer( "process-pom" );
260
261 recordDbConsumers();
262
263 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
264 configControl.expectAndReturn( config.getDatabaseScanning(), dbScanning );
265
266 config.setDatabaseScanning( dbScanning );
267 configControl.setMatcher( MockControl.ALWAYS_MATCHER );
268 configControl.setVoidCallable();
269
270 archivaConfig.save( config );
271 archivaConfigControl.setVoidCallable();
272
273 dbConsumersUtilControl.replay();
274 cleanupConsumersControl.replay();
275 unprocessedConsumersControl.replay();
276 archivaConfigControl.replay();
277 configControl.replay();
278
279 try
280 {
281 boolean success = service.configureDatabaseConsumer( "process-pom", false );
282 assertTrue( success );
283 }
284 catch ( Exception e )
285 {
286 fail( "An exception should not have been thrown." );
287 }
288
289 dbConsumersUtilControl.verify();
290 cleanupConsumersControl.verify();
291 unprocessedConsumersControl.verify();
292 archivaConfigControl.verify();
293 configControl.verify();
294 }
295
296 public void testConfigureInvalidDatabaseConsumer()
297 throws Exception
298 {
299 recordDbConsumers();
300
301 dbConsumersUtilControl.replay();
302 cleanupConsumersControl.replay();
303 unprocessedConsumersControl.replay();
304
305 try
306 {
307 service.configureDatabaseConsumer( "invalid-consumer", true );
308 fail( "An exception should have been thrown." );
309 }
310 catch ( Exception e )
311 {
312 assertEquals( "Invalid database consumer.", e.getMessage() );
313 }
314
315 dbConsumersUtilControl.verify();
316 cleanupConsumersControl.verify();
317 unprocessedConsumersControl.verify();
318 }
319
320
321
322 public void testGetAllRepoConsumers()
323 throws Exception
324 {
325 recordRepoConsumers();
326
327 repoConsumerUtilsControl.replay();
328 knownContentConsumerControl.replay();
329 invalidContentConsumerControl.replay();
330
331 List<String> repoConsumers = service.getAllRepositoryConsumers();
332
333 repoConsumerUtilsControl.verify();
334 knownContentConsumerControl.verify();
335 invalidContentConsumerControl.verify();
336
337 assertNotNull( repoConsumers );
338 assertEquals( 4, repoConsumers.size() );
339 assertTrue( repoConsumers.contains( "index-artifact" ) );
340 assertTrue( repoConsumers.contains( "index-pom" ) );
341 assertTrue( repoConsumers.contains( "check-pom" ) );
342 assertTrue( repoConsumers.contains( "check-metadata" ) );
343 }
344
345 public void testConfigureValidRepositoryConsumer()
346 throws Exception
347 {
348 RepositoryScanningConfiguration repoScanning = new RepositoryScanningConfiguration();
349 repoScanning.addKnownContentConsumer( "index-artifact" );
350 repoScanning.addKnownContentConsumer( "index-pom" );
351 repoScanning.addInvalidContentConsumer( "check-pom" );
352
353
354 recordRepoConsumers();
355
356 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
357 configControl.expectAndReturn( config.getRepositoryScanning(), repoScanning );
358
359 config.setRepositoryScanning( repoScanning );
360 configControl.setMatcher( MockControl.ALWAYS_MATCHER );
361 configControl.setVoidCallable();
362
363 archivaConfig.save( config );
364 archivaConfigControl.setVoidCallable();
365
366 repoConsumerUtilsControl.replay();
367 knownContentConsumerControl.replay();
368 invalidContentConsumerControl.replay();
369 archivaConfigControl.replay();
370 configControl.replay();
371
372 try
373 {
374 boolean success = service.configureRepositoryConsumer( null, "check-metadata", true );
375 assertTrue( success );
376 }
377 catch ( Exception e )
378 {
379 fail( "An exception should not have been thrown." );
380 }
381
382 repoConsumerUtilsControl.verify();
383 knownContentConsumerControl.verify();
384 invalidContentConsumerControl.verify();
385 archivaConfigControl.verify();
386 configControl.verify();
387
388
389 repoConsumerUtilsControl.reset();
390 knownContentConsumerControl.reset();
391 invalidContentConsumerControl.reset();
392 archivaConfigControl.reset();
393 configControl.reset();
394
395 repoScanning.addInvalidContentConsumer( "check-metadata" );
396
397 recordRepoConsumers();
398
399 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
400 configControl.expectAndReturn( config.getRepositoryScanning(), repoScanning );
401
402 config.setRepositoryScanning( repoScanning );
403 configControl.setMatcher( MockControl.ALWAYS_MATCHER );
404 configControl.setVoidCallable();
405
406 archivaConfig.save( config );
407 archivaConfigControl.setVoidCallable();
408
409 repoConsumerUtilsControl.replay();
410 knownContentConsumerControl.replay();
411 invalidContentConsumerControl.replay();
412 archivaConfigControl.replay();
413 configControl.replay();
414
415 try
416 {
417 boolean success = service.configureRepositoryConsumer( null, "check-metadata", false );
418
419 repoConsumerUtilsControl.verify();
420 knownContentConsumerControl.verify();
421 invalidContentConsumerControl.verify();
422 archivaConfigControl.verify();
423 configControl.verify();
424
425 assertTrue( success );
426 }
427 catch ( Exception e )
428 {
429 fail( "An excecption should not have been thrown." );
430 }
431 }
432
433
434 public void testConfigureInvalidRepositoryConsumer()
435 throws Exception
436 {
437 recordRepoConsumers();
438
439 repoConsumerUtilsControl.replay();
440 knownContentConsumerControl.replay();
441 invalidContentConsumerControl.replay();
442
443 try
444 {
445 service.configureRepositoryConsumer( null, "invalid-consumer", true );
446 fail( "An exception should have been thrown." );
447 }
448 catch ( Exception e )
449 {
450 assertEquals( "Invalid repository consumer.", e.getMessage() );
451 }
452
453 repoConsumerUtilsControl.verify();
454 knownContentConsumerControl.verify();
455 invalidContentConsumerControl.verify();
456 }
457
458
459
460 public void testDeleteM2ArtifactArtifactExists()
461 throws Exception
462 {
463 ManagedRepositoryConfiguration managedRepo = createManagedRepo("default", "default-repo");
464
465 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
466 configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), managedRepo );
467
468 ManagedDefaultRepositoryContent repoContent = new ManagedDefaultRepositoryContent();
469 repoContent.setRepository( managedRepo );
470
471 repoFactoryControl.expectAndReturn( repositoryFactory.getManagedRepositoryContent( "internal" ), repoContent );
472
473 List<ArchivaArtifact> artifacts = getArtifacts();
474
475 artifactDao.queryArtifacts( null );
476 artifactDaoControl.setMatcher( MockControl.ALWAYS_MATCHER );
477 artifactDaoControl.setReturnValue( artifacts );
478
479 listener.deleteArtifact( repoContent, artifacts.get( 0 ) );
480 listenerControl.setVoidCallable( 1 );
481
482 archivaConfigControl.replay();
483 configControl.replay();
484 repoFactoryControl.replay();
485 artifactDaoControl.replay();
486 listenerControl.replay();
487
488 boolean success = service.deleteArtifact( "internal", "org.apache.archiva", "archiva-test", "1.0" );
489 assertTrue( success );
490
491 archivaConfigControl.verify();
492 configControl.verify();
493 repoFactoryControl.verify();
494 artifactDaoControl.verify();
495 listenerControl.verify();
496
497 assertFalse( new File( managedRepo.getLocation(), "org/apache/archiva/archiva-test/1.0" ).exists() );
498 assertTrue( new File( managedRepo.getLocation(), "org/apache/archiva/archiva-test/1.1" ).exists() );
499 }
500
501 public void testDeleteM1ArtifactArtifactExists()
502 throws Exception
503 {
504 MockControl fileTypesControl = MockClassControl.createControl( FileTypes.class );
505 FileTypes fileTypes = ( FileTypes ) fileTypesControl.getMock();
506
507 MockControl pathParserControl = MockClassControl.createControl( PathParser.class );
508 PathParser parser = ( PathParser ) pathParserControl.getMock();
509
510 ManagedRepositoryConfiguration managedRepo = createManagedRepo( "legacy", "legacy-repo" );
511
512 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
513 configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), managedRepo );
514
515 ManagedLegacyRepositoryContent repoContent = new ManagedLegacyRepositoryContent();
516 repoContent.setRepository( managedRepo );
517 repoContent.setFileTypes( fileTypes );
518 repoContent.setLegacyPathParser( parser );
519
520 repoFactoryControl.expectAndReturn( repositoryFactory.getManagedRepositoryContent( "internal" ), repoContent );
521
522 recordInManagedLegacyRepoContent( fileTypesControl, fileTypes, pathParserControl, parser );
523
524 List<ArchivaArtifact> artifacts = getArtifacts();
525
526 artifactDao.queryArtifacts( null );
527 artifactDaoControl.setMatcher( MockControl.ALWAYS_MATCHER );
528 artifactDaoControl.setReturnValue( artifacts );
529
530 listener.deleteArtifact( repoContent, artifacts.get( 0 ) );
531 listenerControl.setVoidCallable( 1 );
532
533 archivaConfigControl.replay();
534 configControl.replay();
535 repoFactoryControl.replay();
536 artifactDaoControl.replay();
537 listenerControl.replay();
538 fileTypesControl.replay();
539 pathParserControl.replay();
540
541 boolean success = service.deleteArtifact( "internal", "org.apache.archiva", "archiva-test", "1.0" );
542 assertTrue( success );
543
544 archivaConfigControl.verify();
545 configControl.verify();
546 repoFactoryControl.verify();
547 artifactDaoControl.verify();
548 listenerControl.verify();
549 fileTypesControl.verify();
550 pathParserControl.verify();
551
552 File repo = new File( managedRepo.getLocation() );
553 assertFalse( new File( repo, "org.apache.archiva/jars/archiva-test-1.0.jar" ).exists() );
554 assertFalse( new File( repo, "org.apache.archiva/poms/archiva-test-1.0.pom" ).exists() );
555
556 assertTrue( new File( repo, "org.apache.archiva/jars/archiva-test-1.1.jar" ).exists() );
557 assertTrue( new File( repo, "org.apache.archiva/jars/archiva-diff-1.0.jar" ).exists() );
558 assertTrue( new File( repo, "org.apache.archiva/poms/archiva-test-1.1.pom" ).exists() );
559 assertTrue( new File( repo, "org.apache.archiva/poms/archiva-diff-1.0.pom" ).exists() );
560 }
561
562 public void testDeleteArtifactArtifactDoesNotExist()
563 throws Exception
564 {
565 ManagedRepositoryConfiguration managedRepo = createManagedRepo("default", "default-repo");
566
567 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
568 configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), managedRepo );
569
570 ManagedDefaultRepositoryContent repoContent = new ManagedDefaultRepositoryContent();
571 repoContent.setRepository( managedRepo );
572
573 repoFactoryControl.expectAndReturn( repositoryFactory.getManagedRepositoryContent( "internal" ), repoContent );
574
575 archivaConfigControl.replay();
576 configControl.replay();
577 repoFactoryControl.replay();
578
579 try
580 {
581 service.deleteArtifact( "internal", "org.apache.archiva", "archiva-non-existing", "1.0" );
582 fail( "An exception should have been thrown." );
583 }
584 catch ( Exception e )
585 {
586 assertEquals( "Artifact does not exist.", e.getMessage() );
587 }
588
589 archivaConfigControl.verify();
590 configControl.verify();
591 repoFactoryControl.verify();
592 }
593
594 private ManagedRepositoryConfiguration createManagedRepo(String layout, String directory)
595 throws IOException
596 {
597 File srcDir = new File( getBasedir(), "src/test/repositories/"+ directory );
598
599 File repoDir = getTestFile( "target/test-repos/" + directory );
600
601 FileUtils.deleteDirectory( repoDir );
602
603 FileUtils.copyDirectory( srcDir, repoDir, FileFilterUtils.makeSVNAware( null ) );
604
605 ManagedRepositoryConfiguration managedRepo =
606 createManagedRepo( "internal", layout, "Internal Repository", true, false );
607 managedRepo.setLocation( repoDir.getAbsolutePath() );
608 return managedRepo;
609 }
610
611 public void testDeleteArtifacRepositoryDoesNotExist()
612 throws Exception
613 {
614 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
615 configControl.expectAndReturn( config.findManagedRepositoryById( "non-existing-repo" ), null );
616
617 archivaConfigControl.replay();
618 configControl.replay();
619
620 try
621 {
622 service.deleteArtifact( "non-existing-repo", "org.apache.archiva", "archiva-test", "1.0" );
623 fail( "An exception should have been thrown." );
624 }
625 catch ( Exception e )
626 {
627 assertEquals( "Repository does not exist.", e.getMessage() );
628 }
629
630 archivaConfigControl.verify();
631 configControl.verify();
632 }
633
634
635
636 public void testExecuteRepoScannerRepoExistsAndNotBeingScanned()
637 throws Exception
638 {
639 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
640 configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ),
641 createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
642
643 RepositoryTask task = new RepositoryTask();
644
645 taskSchedulerControl.expectAndReturn( taskScheduler.isProcessingRepositoryTask( "internal" ), false );
646
647 taskScheduler.queueRepositoryTask( task );
648 taskSchedulerControl.setMatcher( MockControl.ALWAYS_MATCHER );
649 taskSchedulerControl.setVoidCallable();
650
651 archivaConfigControl.replay();
652 configControl.replay();
653 taskSchedulerControl.replay();
654
655 try
656 {
657 boolean success = service.executeRepositoryScanner( "internal" );
658 assertTrue( success );
659 }
660 catch ( Exception e )
661 {
662 fail( "An exception should not have been thrown." );
663 }
664
665 archivaConfigControl.verify();
666 configControl.verify();
667 taskSchedulerControl.verify();
668 }
669
670 public void testExecuteRepoScannerRepoExistsButBeingScanned()
671 throws Exception
672 {
673 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
674 configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ),
675 createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
676
677 taskSchedulerControl.expectAndReturn( taskScheduler.isProcessingRepositoryTask( "internal" ), true);
678
679 archivaConfigControl.replay();
680 configControl.replay();
681 taskSchedulerControl.replay();
682
683 try
684 {
685 boolean success = service.executeRepositoryScanner( "internal" );
686 assertFalse( success );
687 }
688 catch ( Exception e )
689 {
690 fail( "An exception should not have been thrown." );
691 }
692
693 archivaConfigControl.verify();
694 configControl.verify();
695 taskSchedulerControl.verify();
696 }
697
698 public void testExecuteRepoScannerRepoDoesNotExist()
699 throws Exception
700 {
701 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
702 configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), null );
703
704 archivaConfigControl.replay();
705 configControl.replay();
706
707 try
708 {
709 service.executeRepositoryScanner( "internal" );
710 fail( "An exception should have been thrown." );
711 }
712 catch ( Exception e )
713 {
714 assertEquals( "Repository does not exist.", e.getMessage() );
715 }
716
717 archivaConfigControl.verify();
718 configControl.verify();
719 }
720
721
722
723 public void testExecuteDbScannerDbNotBeingScanned()
724 throws Exception
725 {
726 DatabaseTask task = new DatabaseTask();
727
728 taskSchedulerControl.expectAndReturn( taskScheduler.isProcessingDatabaseTask(), false );
729
730 taskScheduler.queueDatabaseTask( task );
731 taskSchedulerControl.setMatcher( MockControl.ALWAYS_MATCHER );
732 taskSchedulerControl.setVoidCallable();
733
734 taskSchedulerControl.replay();
735
736 boolean success = service.executeDatabaseScanner();
737
738 taskSchedulerControl.verify();
739
740 assertTrue( success );
741 }
742
743 public void testExecuteDbScannerDbIsBeingScanned()
744 throws Exception
745 {
746 taskSchedulerControl.expectAndReturn( taskScheduler.isProcessingDatabaseTask(), true );
747
748 taskSchedulerControl.replay();
749
750 boolean success = service.executeDatabaseScanner();
751
752 taskSchedulerControl.verify();
753
754 assertFalse( success );
755 }
756
757
758
759 public void testGetAllManagedRepositories()
760 throws Exception
761 {
762 List<ManagedRepositoryConfiguration> managedRepos = new ArrayList<ManagedRepositoryConfiguration>();
763 managedRepos.add( createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
764 managedRepos.add( createManagedRepo( "snapshots", "default", "Snapshots Repository", false, true ) );
765
766 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
767 configControl.expectAndReturn( config.getManagedRepositories(), managedRepos );
768
769 archivaConfigControl.replay();
770 configControl.replay();
771
772 List<ManagedRepository> repos = service.getAllManagedRepositories();
773
774 archivaConfigControl.verify();
775 configControl.verify();
776
777 assertNotNull( repos );
778 assertEquals( 2, repos.size() );
779
780 assertManagedRepo( ( ManagedRepository ) repos.get( 0 ), managedRepos.get( 0 ) );
781 assertManagedRepo( ( ManagedRepository ) repos.get( 1 ), managedRepos.get( 1 ) );
782 }
783
784 public void testGetAllRemoteRepositories()
785 throws Exception
786 {
787 List<RemoteRepositoryConfiguration> remoteRepos = new ArrayList<RemoteRepositoryConfiguration>();
788 remoteRepos.add( createRemoteRepository( "central", "Central Repository", "default", "http://repo1.maven.org/maven2") );
789 remoteRepos.add( createRemoteRepository( "dummy", "Dummy Remote Repository", "legacy", "http://dummy.com/dummy") );
790
791 archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
792 configControl.expectAndReturn( config.getRemoteRepositories(), remoteRepos );
793
794 archivaConfigControl.replay();
795 configControl.replay();
796
797 List<RemoteRepository> repos = service.getAllRemoteRepositories();
798
799 archivaConfigControl.verify();
800 configControl.verify();
801
802 assertNotNull( repos );
803 assertEquals( 2, repos.size() );
804
805 assertRemoteRepo( (RemoteRepository) repos.get( 0 ), remoteRepos.get( 0 ) );
806 assertRemoteRepo( (RemoteRepository) repos.get( 1 ), remoteRepos.get( 1 ) );
807 }
808
809
810
811 private void assertRemoteRepo( RemoteRepository remoteRepo, RemoteRepositoryConfiguration expectedRepoConfig )
812 {
813 assertEquals( expectedRepoConfig.getId(), remoteRepo.getId() );
814 assertEquals( expectedRepoConfig.getLayout(), remoteRepo.getLayout() );
815 assertEquals( expectedRepoConfig.getName(), remoteRepo.getName() );
816 assertEquals( expectedRepoConfig.getUrl(), remoteRepo.getUrl() );
817 }
818
819 private RemoteRepositoryConfiguration createRemoteRepository(String id, String name, String layout, String url)
820 {
821 RemoteRepositoryConfiguration remoteConfig = new RemoteRepositoryConfiguration();
822 remoteConfig.setId( id );
823 remoteConfig.setName( name );
824 remoteConfig.setLayout( layout );
825 remoteConfig.setUrl( url );
826
827 return remoteConfig;
828 }
829
830 private void assertManagedRepo( ManagedRepository managedRepo, ManagedRepositoryConfiguration expectedRepoConfig )
831 {
832 assertEquals( expectedRepoConfig.getId(), managedRepo.getId() );
833 assertEquals( expectedRepoConfig.getLayout(), managedRepo.getLayout() );
834 assertEquals( expectedRepoConfig.getName(), managedRepo.getName() );
835
836
837
838 assertEquals( expectedRepoConfig.isReleases(), managedRepo.isReleases() );
839 assertEquals( expectedRepoConfig.isSnapshots(), managedRepo.isSnapshots() );
840 }
841
842 private ManagedRepositoryConfiguration createManagedRepo( String id, String layout, String name,
843 boolean hasReleases, boolean hasSnapshots )
844 {
845 ManagedRepositoryConfiguration repoConfig = new ManagedRepositoryConfiguration();
846 repoConfig.setId( id );
847 repoConfig.setLayout( layout );
848 repoConfig.setName( name );
849 repoConfig.setReleases( hasReleases );
850 repoConfig.setSnapshots( hasSnapshots );
851
852 return repoConfig;
853 }
854
855 private void recordRepoConsumers()
856 {
857 List<KnownRepositoryContentConsumer> availableKnownConsumers = new ArrayList<KnownRepositoryContentConsumer>();
858 availableKnownConsumers.add( indexArtifactConsumer );
859 availableKnownConsumers.add( indexPomConsumer );
860
861 List<InvalidRepositoryContentConsumer> availableInvalidConsumers = new ArrayList<InvalidRepositoryContentConsumer>();
862 availableInvalidConsumers.add( checkPomConsumer );
863 availableInvalidConsumers.add( checkMetadataConsumer );
864
865 repoConsumerUtilsControl.expectAndReturn( repoConsumersUtil.getAvailableKnownConsumers(), availableKnownConsumers );
866 knownContentConsumerControl.expectAndReturn( indexArtifactConsumer.getId(), "index-artifact" );
867 knownContentConsumerControl.expectAndReturn( indexPomConsumer.getId(), "index-pom" );
868
869 repoConsumerUtilsControl.expectAndReturn( repoConsumersUtil.getAvailableInvalidConsumers(), availableInvalidConsumers );
870 invalidContentConsumerControl.expectAndReturn( checkPomConsumer.getId(), "check-pom" );
871 invalidContentConsumerControl.expectAndReturn( checkMetadataConsumer.getId(), "check-metadata" );
872 }
873
874 private void recordDbConsumers()
875 {
876 List<DatabaseCleanupConsumer> cleanupConsumers = new ArrayList<DatabaseCleanupConsumer>();
877 cleanupConsumers.add( cleanupIndexConsumer );
878 cleanupConsumers.add( cleanupDbConsumer );
879
880 List<DatabaseUnprocessedArtifactConsumer> unprocessedConsumers =
881 new ArrayList<DatabaseUnprocessedArtifactConsumer>();
882 unprocessedConsumers.add( processArtifactConsumer );
883 unprocessedConsumers.add( processPomConsumer );
884
885 dbConsumersUtilControl.expectAndReturn( dbConsumersUtil.getAvailableCleanupConsumers(), cleanupConsumers );
886 cleanupConsumersControl.expectAndReturn( cleanupIndexConsumer.getId(), "cleanup-index" );
887 cleanupConsumersControl.expectAndReturn( cleanupDbConsumer.getId(), "cleanup-database" );
888
889 dbConsumersUtilControl.expectAndReturn( dbConsumersUtil.getAvailableUnprocessedConsumers(), unprocessedConsumers );
890 unprocessedConsumersControl.expectAndReturn( processArtifactConsumer.getId(), "process-artifact" );
891 unprocessedConsumersControl.expectAndReturn( processPomConsumer.getId(), "process-pom" );
892 }
893
894 private void recordInManagedLegacyRepoContent( MockControl fileTypesControl, FileTypes fileTypes,
895 MockControl pathParserControl, PathParser parser )
896 throws LayoutException
897 {
898 String sep = File.separator;
899 String ad10p = "org.apache.archiva" + sep + "poms" + sep + "archiva-diff-1.0.pom";
900 String at10p = "org.apache.archiva" + sep + "poms" + sep + "archiva-test-1.0.pom";
901 String at11p = "org.apache.archiva" + sep + "poms" + sep + "archiva-test-1.1.pom";
902 String ad10j = "org.apache.archiva" + sep + "jars" + sep + "archiva-diff-1.0.jar";
903 String at10j = "org.apache.archiva" + sep + "jars" + sep + "archiva-test-1.0.jar";
904 String at11j = "org.apache.archiva" + sep + "jars" + sep + "archiva-test-1.1.jar";
905
906 fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at10p ), true );
907 fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at11p ), true );
908 fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( ad10p ), true );
909 fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( ad10j ), true );
910 fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at10j ), true );
911 fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at11j ), true );
912
913 ArtifactReference aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.1", "pom");
914 pathParserControl.expectAndReturn( parser.toArtifactReference( at11p ), aRef );
915
916 aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.0", "pom");
917 pathParserControl.expectAndReturn( parser.toArtifactReference( at10p ), aRef );
918
919 aRef = createArtifactReference("archiva-diff", "org.apache.archiva", "1.0", "pom");
920 pathParserControl.expectAndReturn( parser.toArtifactReference( ad10p ), aRef );
921
922 aRef = createArtifactReference("archiva-diff", "org.apache.archiva", "1.0", "jar");
923 pathParserControl.expectAndReturn( parser.toArtifactReference( ad10j ), aRef );
924
925 aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.0", "jar");
926 pathParserControl.expectAndReturn( parser.toArtifactReference( at10j ), aRef );
927
928 aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.1", "jar");
929 pathParserControl.expectAndReturn( parser.toArtifactReference( at11j ), aRef );
930 }
931
932 private List<ArchivaArtifact> getArtifacts()
933 {
934 List<ArchivaArtifact> artifacts = new ArrayList<ArchivaArtifact>();
935
936 ArchivaArtifactModel model = new ArchivaArtifactModel();
937 model.setRepositoryId( "internal" );
938 model.setGroupId( "org.apache.archiva" );
939 model.setArtifactId( "archiva-test" );
940 model.setVersion( "1.0" );
941 model.setType( "jar" );
942
943 ArchivaArtifact artifact = new ArchivaArtifact( model );
944 artifacts.add( artifact );
945 return artifacts;
946 }
947
948 private ArtifactReference createArtifactReference( String artifactId, String groupId, String version, String type )
949 {
950 ArtifactReference aRef = new ArtifactReference();
951 aRef.setArtifactId( artifactId );
952 aRef.setGroupId( groupId );
953 aRef.setType( type );
954 aRef.setVersion( version );
955
956 return aRef;
957 }
958 }