View Javadoc

1   package org.apache.maven.archiva.configuration;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.io.File;
23  import java.util.List;
24  import java.util.Map;
25  
26  import org.apache.commons.io.FileUtils;
27  import org.apache.commons.lang.StringUtils;
28  import org.codehaus.plexus.registry.RegistryException;
29  import org.codehaus.plexus.spring.PlexusInSpringTestCase;
30  import org.custommonkey.xmlunit.XMLAssert;
31  import org.easymock.MockControl;
32  
33  /**
34   * Test the configuration store.
35   *
36   */
37  public class ArchivaConfigurationTest
38      extends PlexusInSpringTestCase
39  {
40      /**
41       * {@inheritDoc}
42       * @see org.codehaus.plexus.spring.PlexusInSpringTestCase#getSpringConfigLocation()
43       */
44      protected String getSpringConfigLocation()
45      {
46          return "org/apache/maven/archiva/configuration/spring-context.xml";
47      }
48  
49      public void testGetConfigurationFromRegistryWithASingleNamedConfigurationResource()
50          throws Exception
51      {
52          ArchivaConfiguration archivaConfiguration =
53              (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-configuration" );
54  
55          Configuration configuration = archivaConfiguration.getConfiguration();
56          assertConfiguration( configuration );
57          assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
58  
59          ManagedRepositoryConfiguration repository =
60              (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
61  
62          assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
63                        repository.getLocation() );
64          assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
65          assertEquals( "check managed repositories", "internal", repository.getId() );
66          assertEquals( "check managed repositories", "default", repository.getLayout() );
67          assertTrue( "check managed repositories", repository.isScanned() );
68      }
69  
70      public void testGetConfigurationFromDefaults()
71          throws Exception
72      {
73          ArchivaConfiguration archivaConfiguration =
74              (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-defaults" );
75  
76          Configuration configuration = archivaConfiguration.getConfiguration();
77          assertConfiguration( configuration );
78          assertEquals( "check network proxies", 0, configuration.getNetworkProxies().size() );
79  
80          ManagedRepositoryConfiguration repository =
81              (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
82  
83          assertEquals( "check managed repositories", "${appserver.base}/data/repositories/internal",
84                        repository.getLocation() );
85          assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
86          assertEquals( "check managed repositories", "internal", repository.getId() );
87          assertEquals( "check managed repositories", "default", repository.getLayout() );
88          assertTrue( "check managed repositories", repository.isScanned() );
89      }
90      
91      // test for [MRM-789]
92      public void testGetConfigurationFromDefaultsWithDefaultRepoLocationAlreadyExisting()
93          throws Exception
94      {
95          File repo = new File( getBasedir(), "/target/test-classes/existing_snapshots" );
96          repo.mkdirs();
97          
98          repo = new File( getBasedir(), "/target/test-classes/existing_internal" );
99          repo.mkdirs();
100         
101         String existingTestDefaultArchivaConfigFile = 
102             FileUtils.readFileToString( getTestFile( "target/test-classes/org/apache/maven/archiva/configuration/test-default-archiva.xml" ) ) ;        
103         existingTestDefaultArchivaConfigFile = StringUtils.replace( existingTestDefaultArchivaConfigFile, "${appserver.base}", getBasedir() );
104         
105         File generatedTestDefaultArchivaConfigFile =
106             new File( getBasedir(), "target/test-classes/org/apache/maven/archiva/configuration/default-archiva.xml" );
107                 
108         FileUtils.writeStringToFile( generatedTestDefaultArchivaConfigFile, existingTestDefaultArchivaConfigFile, null );
109                 
110         ArchivaConfiguration archivaConfiguration =
111             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), 
112                                            "test-defaults-default-repo-location-exists" );
113 
114         Configuration configuration = archivaConfiguration.getConfiguration();
115         assertConfiguration( configuration );
116         
117         ManagedRepositoryConfiguration repository =
118             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );        
119         assertTrue( "check managed repositories", repository.getLocation().endsWith( "data/repositories/internal" ) );
120         
121         generatedTestDefaultArchivaConfigFile.delete();
122         assertFalse( generatedTestDefaultArchivaConfigFile.exists() );
123     }
124     
125     /**
126      * Ensures that the provided configuration matches the details present in the archiva-default.xml file.
127      */
128     private void assertConfiguration( Configuration configuration )
129         throws Exception
130     {
131         FileTypes filetypes = (FileTypes) lookup( FileTypes.class.getName() );
132 
133         assertEquals( "check repositories", 2, configuration.getManagedRepositories().size() );
134         assertEquals( "check repositories", 2, configuration.getRemoteRepositories().size() );
135         assertEquals( "check proxy connectors", 2, configuration.getProxyConnectors().size() );
136 
137         RepositoryScanningConfiguration repoScanning = configuration.getRepositoryScanning();
138         assertNotNull( "check repository scanning", repoScanning );
139         assertEquals( "check file types", 4, repoScanning.getFileTypes().size() );
140         assertEquals( "check known consumers", 9, repoScanning.getKnownContentConsumers().size() );
141         assertEquals( "check invalid consumers", 1, repoScanning.getInvalidContentConsumers().size() );
142 
143         List<String> patterns = filetypes.getFileTypePatterns( "artifacts" );
144         assertNotNull( "check 'artifacts' file type", patterns );
145         assertEquals( "check 'artifacts' patterns", 13, patterns.size() );
146 
147         DatabaseScanningConfiguration dbScanning = configuration.getDatabaseScanning();
148         assertNotNull( "check database scanning", dbScanning );
149         assertEquals( "check unprocessed consumers", 6, dbScanning.getUnprocessedConsumers().size() );
150         assertEquals( "check cleanup consumers", 3, dbScanning.getCleanupConsumers().size() );
151 
152         WebappConfiguration webapp = configuration.getWebapp();
153         assertNotNull( "check webapp", webapp );
154 
155         UserInterfaceOptions ui = webapp.getUi();
156         assertNotNull( "check webapp ui", ui );
157         assertTrue( "check showFindArtifacts", ui.isShowFindArtifacts() );
158         assertTrue( "check appletFindEnabled", ui.isAppletFindEnabled() );
159     }
160 
161     public void testGetConfigurationFromRegistryWithTwoConfigurationResources()
162         throws Exception
163     {
164         ArchivaConfiguration archivaConfiguration =
165             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-configuration-both" );
166 
167         Configuration configuration = archivaConfiguration.getConfiguration();
168 
169         // from base
170         assertEquals( "check repositories", 2, configuration.getManagedRepositories().size() );
171         assertEquals( "check repositories", 2, configuration.getRemoteRepositories().size() );
172         // from user
173         assertEquals( "check proxy connectors", 2, configuration.getProxyConnectors().size() );
174 
175         WebappConfiguration webapp = configuration.getWebapp();
176         assertNotNull( "check webapp", webapp );
177 
178         UserInterfaceOptions ui = webapp.getUi();
179         assertNotNull( "check webapp ui", ui );
180         // from base
181         assertFalse( "check showFindArtifacts", ui.isShowFindArtifacts() );
182         // from user
183         assertFalse( "check appletFindEnabled", ui.isAppletFindEnabled() );
184     }
185 
186     public void testGetConfigurationSystemOverride()
187         throws Exception
188     {
189 
190         System.setProperty( "org.apache.maven.archiva.webapp.ui.appletFindEnabled", "false" );
191 
192         ArchivaConfiguration archivaConfiguration =
193             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-configuration" );
194 
195         try
196         {
197             Configuration configuration = archivaConfiguration.getConfiguration();
198 
199             assertFalse( "check boolean", configuration.getWebapp().getUi().isAppletFindEnabled() );
200         }
201         finally
202         {
203             System.getProperties().remove( "org.apache.maven.archiva.webapp.ui.appletFindEnabled" );
204         }
205     }
206 
207     public void testStoreConfiguration()
208         throws Exception
209     {
210         File file = getTestFile( "target/test/test-file.xml" );
211         file.delete();
212         assertFalse( file.exists() );
213 
214         // TODO: remove with commons-configuration 1.4
215         file.getParentFile().mkdirs();
216         FileUtils.writeStringToFile( file, "<configuration/>", null );
217 
218         DefaultArchivaConfiguration archivaConfiguration =
219             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save" );
220 
221         Configuration configuration = new Configuration();
222         configuration.setVersion( "1" );
223         configuration.setWebapp( new WebappConfiguration() );
224         configuration.getWebapp().setUi( new UserInterfaceOptions() );
225         configuration.getWebapp().getUi().setAppletFindEnabled( false );
226 
227         // add a change listener
228         MockControl control = createConfigurationListenerMockControl();
229         ConfigurationListener listener = (ConfigurationListener) control.getMock();
230         archivaConfiguration.addListener( listener );
231 
232         listener.configurationEvent( new ConfigurationEvent( ConfigurationEvent.SAVED ) );
233         control.setVoidCallable();
234 
235         control.replay();
236 
237         archivaConfiguration.save( configuration );
238 
239         control.verify();
240 
241         assertTrue( "Check file exists", file.exists() );
242 
243         // check it
244         configuration = archivaConfiguration.getConfiguration();
245         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
246 
247         // read it back
248         archivaConfiguration =
249             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-read-saved" );
250         configuration = archivaConfiguration.getConfiguration();
251         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
252     }
253 
254     private static MockControl createConfigurationListenerMockControl()
255     {
256         return MockControl.createControl( ConfigurationListener.class );
257     }
258 
259     public void testStoreConfigurationUser()
260         throws Exception
261     {
262         File baseFile = getTestFile( "target/test/test-file.xml" );
263         baseFile.delete();
264         assertFalse( baseFile.exists() );
265 
266         File userFile = getTestFile( "target/test/test-file-user.xml" );
267         userFile.delete();
268         assertFalse( userFile.exists() );
269 
270         userFile.getParentFile().mkdirs();
271         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
272 
273         ArchivaConfiguration archivaConfiguration =
274             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
275 
276         Configuration configuration = new Configuration();
277         configuration.setWebapp( new WebappConfiguration() );
278         configuration.getWebapp().setUi( new UserInterfaceOptions() );
279         configuration.getWebapp().getUi().setAppletFindEnabled( false );
280 
281         archivaConfiguration.save( configuration );
282 
283         assertTrue( "Check file exists", userFile.exists() );
284         assertFalse( "Check file not created", baseFile.exists() );
285 
286         // check it
287         configuration = archivaConfiguration.getConfiguration();
288         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
289     }
290 
291     public void testStoreConfigurationLoadedFromDefaults()
292         throws Exception
293     {
294         File baseFile = getTestFile( "target/test/test-file.xml" );
295         baseFile.delete();
296         assertFalse( baseFile.exists() );
297 
298         File userFile = getTestFile( "target/test/test-file-user.xml" );
299         userFile.delete();
300         assertFalse( userFile.exists() );
301 
302         ArchivaConfiguration archivaConfiguration =
303             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
304 
305         Configuration configuration = new Configuration();
306         configuration.setWebapp( new WebappConfiguration() );
307         configuration.getWebapp().setUi( new UserInterfaceOptions() );
308         configuration.getWebapp().getUi().setAppletFindEnabled( false );
309 
310         // add a change listener
311         MockControl control = createConfigurationListenerMockControl();
312         ConfigurationListener listener = (ConfigurationListener) control.getMock();
313         archivaConfiguration.addListener( listener );
314 
315         listener.configurationEvent( new ConfigurationEvent( ConfigurationEvent.SAVED ) );
316         // once from default creation, and again from manual call to save
317         control.setVoidCallable( 2 );
318 
319         control.replay();
320 
321         archivaConfiguration.save( configuration );
322 
323         control.verify();
324 
325         assertTrue( "Check file exists", userFile.exists() );
326         assertFalse( "Check file not created", baseFile.exists() );
327 
328         // check it
329         configuration = archivaConfiguration.getConfiguration();
330         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
331     }
332 
333     public void testDefaultUserConfigFilename()
334         throws Exception
335     {
336         DefaultArchivaConfiguration archivaConfiguration =
337             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName() );
338 
339         assertEquals( System.getProperty( "user.home" ) + "/.m2/archiva.xml",
340                       archivaConfiguration.getUserConfigFilename() );
341         assertEquals( System.getProperty( "appserver.base", "${appserver.base}" ) + "/conf/archiva.xml",
342                       archivaConfiguration.getAltConfigFilename() );
343     }
344 
345     public void testStoreConfigurationFallback()
346         throws Exception
347     {
348         File baseFile = getTestFile( "target/test/test-file.xml" );
349         baseFile.delete();
350         assertFalse( baseFile.exists() );
351 
352         File userFile = getTestFile( "target/test/test-file-user.xml" );
353         userFile.delete();
354         assertFalse( userFile.exists() );
355 
356         baseFile.getParentFile().mkdirs();
357         FileUtils.writeStringToFile( baseFile, "<configuration/>", null );
358 
359         ArchivaConfiguration archivaConfiguration =
360             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
361 
362         Configuration configuration = new Configuration();
363         configuration.setWebapp( new WebappConfiguration() );
364         configuration.getWebapp().setUi( new UserInterfaceOptions() );
365         configuration.getWebapp().getUi().setAppletFindEnabled( false );
366 
367         archivaConfiguration.save( configuration );
368 
369         assertTrue( "Check file exists", baseFile.exists() );
370         assertFalse( "Check file not created", userFile.exists() );
371 
372         // check it
373         configuration = archivaConfiguration.getConfiguration();
374         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
375     }
376 
377     public void testStoreConfigurationFailsWhenReadFromBothLocationsNoLists()
378         throws Exception
379     {
380         File baseFile = getTestFile( "target/test/test-file.xml" );
381         baseFile.delete();
382         assertFalse( baseFile.exists() );
383 
384         File userFile = getTestFile( "target/test/test-file-user.xml" );
385         userFile.delete();
386         assertFalse( userFile.exists() );
387 
388         baseFile.getParentFile().mkdirs();
389         FileUtils.writeStringToFile( baseFile, "<configuration/>", null );
390 
391         userFile.getParentFile().mkdirs();
392         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
393 
394         ArchivaConfiguration archivaConfiguration =
395             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
396 
397         Configuration configuration = archivaConfiguration.getConfiguration();
398         assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
399 
400         configuration.getWebapp().getUi().setAppletFindEnabled( false );
401 
402         archivaConfiguration.save( configuration );
403 
404         assertTrue( "Check file exists", baseFile.exists() );
405         assertEquals( "Check base file is unchanged", "<configuration/>",
406                       FileUtils.readFileToString( baseFile, null ) );
407         assertTrue( "Check file exists", userFile.exists() );
408         assertFalse( "Check base file is changed",
409                      "<configuration/>".equals( FileUtils.readFileToString( userFile, null ) ) );
410 
411         // check it
412         configuration = archivaConfiguration.getConfiguration();
413         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
414     }
415 
416     public void testStoreConfigurationFailsWhenReadFromBothLocationsUserHasLists()
417         throws Exception
418     {
419         File baseFile = getTestFile( "target/test/test-file.xml" );
420         baseFile.delete();
421         assertFalse( baseFile.exists() );
422 
423         File userFile = getTestFile( "target/test/test-file-user.xml" );
424         userFile.delete();
425         assertFalse( userFile.exists() );
426 
427         userFile.getParentFile().mkdirs();
428         FileUtils.copyFile( getTestFile( "src/test/conf/conf-user.xml" ), userFile );
429 
430         baseFile.getParentFile().mkdirs();
431         FileUtils.writeStringToFile( baseFile, "<configuration/>", null );
432 
433         ArchivaConfiguration archivaConfiguration =
434             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
435 
436         Configuration configuration = archivaConfiguration.getConfiguration();
437         assertTrue( "check value", configuration.getWebapp().getUi().isShowFindArtifacts() );
438 
439         configuration.getWebapp().getUi().setShowFindArtifacts( false );
440 
441         archivaConfiguration.save( configuration );
442 
443         assertTrue( "Check file exists", baseFile.exists() );
444         assertEquals( "Check base file is unchanged", "<configuration/>",
445                       FileUtils.readFileToString( baseFile, null ) );
446         assertTrue( "Check file exists", userFile.exists() );
447         assertFalse( "Check base file is changed",
448                      "<configuration/>".equals( FileUtils.readFileToString( userFile, null ) ) );
449 
450         // check it
451         configuration = archivaConfiguration.getConfiguration();
452         assertFalse( "check value", configuration.getWebapp().getUi().isShowFindArtifacts() );
453     }
454 
455     public void testStoreConfigurationFailsWhenReadFromBothLocationsAppserverHasLists()
456         throws Exception
457     {
458         File baseFile = getTestFile( "target/test/test-file.xml" );
459         baseFile.delete();
460         assertFalse( baseFile.exists() );
461 
462         File userFile = getTestFile( "target/test/test-file-user.xml" );
463         userFile.delete();
464         assertFalse( userFile.exists() );
465 
466         baseFile.getParentFile().mkdirs();
467         FileUtils.copyFile( getTestFile( "src/test/conf/conf-base.xml" ), baseFile );
468 
469         userFile.getParentFile().mkdirs();
470         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
471 
472         ArchivaConfiguration archivaConfiguration =
473             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
474 
475         Configuration configuration = archivaConfiguration.getConfiguration();
476         assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
477 
478         configuration.getWebapp().getUi().setAppletFindEnabled( false );
479 
480         try
481         {
482             archivaConfiguration.save( configuration );
483             fail( "Configuration saving should not succeed if it was loaded from two locations" );
484         }
485         catch ( IndeterminateConfigurationException e )
486         {
487             // check it was reverted
488             configuration = archivaConfiguration.getConfiguration();
489             assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
490         }
491     }
492 
493     public void testLoadConfigurationFromInvalidBothLocationsOnDisk()
494         throws Exception
495     {
496         ArchivaConfiguration archivaConfiguration =
497             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-not-allowed-to-write-to-both" );
498         Configuration config = archivaConfiguration.getConfiguration();
499 
500         try
501         {
502             archivaConfiguration.save( config );
503             fail( "Should have thrown a RegistryException because the configuration can't be saved." );
504         }
505         catch ( RegistryException e )
506         {
507             /* expected exception */
508         }
509     }
510 
511     public void testLoadConfigurationFromInvalidUserLocationOnDisk()
512         throws Exception
513     {
514         File testConfDir = getTestFile( "target/test-appserver-base/conf/" );
515         testConfDir.mkdirs();
516 
517         ArchivaConfiguration archivaConfiguration =
518             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-not-allowed-to-write-to-user" );
519         Configuration config = archivaConfiguration.getConfiguration();
520         archivaConfiguration.save( config );
521         // No Exception == test passes.
522         // Expected Path is: Should not have thrown an exception.
523     }
524 
525     public void testConfigurationUpgradeFrom09()
526         throws Exception
527     {
528         ArchivaConfiguration archivaConfiguration =
529             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-upgrade-09" );
530 
531         // we just use the defaults when upgrading from 0.9 at this point.
532         Configuration configuration = archivaConfiguration.getConfiguration();
533         assertConfiguration( configuration );
534         assertEquals( "check network proxies", 0, configuration.getNetworkProxies().size() );
535 
536         ManagedRepositoryConfiguration repository =
537             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
538 
539         assertEquals( "check managed repositories", "${appserver.base}/data/repositories/internal",
540                       repository.getLocation() );
541         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
542         assertEquals( "check managed repositories", "internal", repository.getId() );
543         assertEquals( "check managed repositories", "default", repository.getLayout() );
544         assertTrue( "check managed repositories", repository.isScanned() );
545     }
546 
547     public void testAutoDetectV1()
548         throws Exception
549     {
550         // Setup the autodetect-v1.xml file in the target directory (so we can save/load it)
551         File userFile = getTestFile( "target/test-autodetect-v1/archiva-user.xml" );
552         userFile.delete();
553         assertFalse( userFile.exists() );
554 
555         userFile.getParentFile().mkdirs();
556         FileUtils.copyFile( getTestFile( "src/test/conf/autodetect-v1.xml" ), userFile );
557 
558         // Load the original (unconverted) archiva.xml
559         ArchivaConfiguration archivaConfiguration =
560             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-autodetect-v1" );
561 
562         Configuration configuration = archivaConfiguration.getConfiguration();
563         assertConfiguration( configuration );
564         assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
565 
566         ManagedRepositoryConfiguration repository =
567             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
568 
569         assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
570                       repository.getLocation() );
571         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
572         assertEquals( "check managed repositories", "internal", repository.getId() );
573         assertEquals( "check managed repositories", "default", repository.getLayout() );
574         assertTrue( "check managed repositories", repository.isScanned() );
575 
576         // Test that only 1 set of repositories exist.
577         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositories().size() );
578         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositories().size() );
579         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
580 
581         // Save the file.
582         archivaConfiguration.save( configuration );
583 
584         // Release existing
585 //      FIXME spring equivalent ?  release( archivaConfiguration );
586 
587         // Reload.
588         archivaConfiguration =
589             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-autodetect-v1" );
590         configuration = archivaConfiguration.getConfiguration();
591 
592         // Test that only 1 set of repositories exist.
593         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositories().size() );
594         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositoriesAsMap().size() );
595         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositories().size() );
596         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositoriesAsMap().size() );
597         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
598 
599         String actualXML = FileUtils.readFileToString( userFile, null );
600         XMLAssert.assertXpathNotExists( "//configuration/repositories/repository", actualXML );
601         XMLAssert.assertXpathNotExists( "//configuration/repositories", actualXML );
602     }
603 
604     public void testArchivaV1()
605         throws Exception
606     {
607         ArchivaConfiguration archivaConfiguration =
608             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-archiva-v1" );
609 
610         Configuration configuration = archivaConfiguration.getConfiguration();
611         assertConfiguration( configuration );
612         assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
613 
614         assertEquals( "check managed repositories", 2, configuration.getManagedRepositories().size() );
615         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
616 
617         Map<String, ManagedRepositoryConfiguration> map = configuration.getManagedRepositoriesAsMap();
618 
619         ManagedRepositoryConfiguration repository = map.get( "internal" );
620         assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
621                       repository.getLocation() );
622         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
623         assertEquals( "check managed repositories", "internal", repository.getId() );
624         assertEquals( "check managed repositories", "default", repository.getLayout() );
625         assertTrue( "check managed repositories", repository.isScanned() );
626         assertFalse( "check managed repositories", repository.isSnapshots() );
627 
628         repository = map.get( "snapshots" );
629         assertEquals( "check managed repositories", "${appserver.base}/repositories/snapshots",
630                       repository.getLocation() );
631         assertEquals( "check managed repositories", "Archiva Managed Snapshot Repository", repository.getName() );
632         assertEquals( "check managed repositories", "snapshots", repository.getId() );
633         assertEquals( "check managed repositories", "default", repository.getLayout() );
634         assertFalse( "check managed repositories", repository.isScanned() );
635         assertTrue( "check managed repositories", repository.isSnapshots() );
636     }
637 
638     public void testCronExpressionsWithComma()
639         throws Exception
640     {
641         File baseFile = getTestFile( "target/test/test-file.xml" );
642         baseFile.delete();
643         assertFalse( baseFile.exists() );
644 
645         File userFile = getTestFile( "target/test/test-file-user.xml" );
646         userFile.delete();
647         assertFalse( userFile.exists() );
648 
649         baseFile.getParentFile().mkdirs();
650         FileUtils.copyFile( getTestFile( "src/test/conf/escape-cron-expressions.xml" ), baseFile );
651 
652         userFile.getParentFile().mkdirs();
653         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
654 
655         final ArchivaConfiguration archivaConfiguration =
656             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-cron-expressions" );
657 
658         Configuration configuration = archivaConfiguration.getConfiguration();
659 
660         ManagedRepositoryConfiguration repository =
661             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
662 
663         assertEquals( "check cron expression", "0 0,30 * * * ?", repository.getRefreshCronExpression().trim() );
664 
665         configuration.getDatabaseScanning().setCronExpression( "0 0,15 0 * * ?" );
666 
667         // add a test listener to confirm it doesn't see the escaped format. We don't need to test the number of calls,
668         // etc. as it's done in other tests
669         archivaConfiguration.addListener( new ConfigurationListener()
670         {
671             public void configurationEvent( ConfigurationEvent event )
672             {
673                 assertEquals( ConfigurationEvent.SAVED, event.getType() );
674 
675                 Configuration configuration = archivaConfiguration.getConfiguration();
676 
677                 assertEquals( "check cron expression", "0 0,15 0 * * ?",
678                               configuration.getDatabaseScanning().getCronExpression() );
679             }
680         } );
681 
682         archivaConfiguration.save( configuration );
683 
684         configuration = archivaConfiguration.getConfiguration();
685 
686         assertEquals( "check cron expression", "0 0,15 0 * * ?",
687                       configuration.getDatabaseScanning().getCronExpression() );
688 
689         // test for the escape character '\' showing up on repositories.jsp
690         repository.setRefreshCronExpression( "0 0,20 0 * * ?" );
691 
692         archivaConfiguration.save( configuration );
693 
694         repository = archivaConfiguration.getConfiguration().findManagedRepositoryById( "snapshots" );
695 
696         assertEquals( "check cron expression", "0 0,20 0 * * ?", repository.getRefreshCronExpression() );
697     }
698 
699     public void testRemoveLastElements()
700         throws Exception
701     {
702         File baseFile = getTestFile( "target/test/test-file.xml" );
703         baseFile.delete();
704         assertFalse( baseFile.exists() );
705 
706         File userFile = getTestFile( "target/test/test-file-user.xml" );
707         userFile.delete();
708         assertFalse( userFile.exists() );
709 
710         baseFile.getParentFile().mkdirs();
711         FileUtils.copyFile( getTestFile( "src/test/conf/conf-single-list-elements.xml" ), baseFile );
712 
713         userFile.getParentFile().mkdirs();
714         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
715 
716         ArchivaConfiguration archivaConfiguration =
717             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-remove-central" );
718 
719         Configuration configuration = archivaConfiguration.getConfiguration();
720        
721         RepositoryGroupConfiguration repositoryGroup = ( RepositoryGroupConfiguration ) configuration.getRepositoryGroups().get( 0 );
722         assertNotNull( repositoryGroup );
723         configuration.removeRepositoryGroup( repositoryGroup );
724         assertTrue( configuration.getRepositoryGroups().isEmpty() );
725         
726         RemoteRepositoryConfiguration repository = configuration.getRemoteRepositoriesAsMap().get( "central" );
727         assertNotNull( repository );
728         configuration.removeRemoteRepository( repository );
729         assertTrue( configuration.getRemoteRepositories().isEmpty() );
730 
731         ManagedRepositoryConfiguration managedRepository =
732             configuration.getManagedRepositoriesAsMap().get( "snapshots" );
733         assertNotNull( managedRepository );
734         configuration.removeManagedRepository( managedRepository );
735         assertTrue( configuration.getManagedRepositories().isEmpty() );
736 
737         ProxyConnectorConfiguration proxyConnector =
738             (ProxyConnectorConfiguration) configuration.getProxyConnectors().get( 0 );
739         assertNotNull( proxyConnector );
740         configuration.removeProxyConnector( proxyConnector );
741         assertTrue( configuration.getProxyConnectors().isEmpty() );
742 
743         NetworkProxyConfiguration networkProxy = configuration.getNetworkProxiesAsMap().get( "proxy" );
744         assertNotNull( networkProxy );
745         configuration.removeNetworkProxy( networkProxy );
746         assertTrue( configuration.getNetworkProxies().isEmpty() );
747 
748         LegacyArtifactPath path = (LegacyArtifactPath) configuration.getLegacyArtifactPaths().get( 0 );
749         assertNotNull( path );
750         configuration.removeLegacyArtifactPath( path );
751         assertTrue( configuration.getLegacyArtifactPaths().isEmpty() );
752 
753         RepositoryScanningConfiguration scanning = configuration.getRepositoryScanning();
754         String consumer = (String) scanning.getKnownContentConsumers().get( 0 );
755         assertNotNull( consumer );
756         scanning.removeKnownContentConsumer( consumer );
757         assertTrue( scanning.getKnownContentConsumers().isEmpty() );
758         consumer = (String) scanning.getInvalidContentConsumers().get( 0 );
759         assertNotNull( consumer );
760         scanning.removeInvalidContentConsumer( consumer );
761         assertTrue( scanning.getInvalidContentConsumers().isEmpty() );
762 
763         DatabaseScanningConfiguration databaseScanning = configuration.getDatabaseScanning();
764         consumer = (String) databaseScanning.getCleanupConsumers().get( 0 );
765         assertNotNull( consumer );
766         databaseScanning.removeCleanupConsumer( consumer );
767         assertTrue( databaseScanning.getCleanupConsumers().isEmpty() );
768         consumer = (String) databaseScanning.getUnprocessedConsumers().get( 0 );
769         assertNotNull( consumer );
770         databaseScanning.removeUnprocessedConsumer( consumer );
771         assertTrue( databaseScanning.getUnprocessedConsumers().isEmpty() );
772 
773         archivaConfiguration.save( configuration );
774 
775         archivaConfiguration =
776             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-read-saved" );
777         configuration = archivaConfiguration.getConfiguration();
778         assertNull( configuration.getRemoteRepositoriesAsMap().get( "central" ) );
779         assertTrue( configuration.getRepositoryGroups().isEmpty() );
780         assertNull( configuration.getManagedRepositoriesAsMap().get( "snapshots" ) );
781         assertTrue( configuration.getProxyConnectors().isEmpty() );
782         assertNull( configuration.getNetworkProxiesAsMap().get( "proxy" ) );
783         assertTrue( configuration.getLegacyArtifactPaths().isEmpty() );
784         scanning = configuration.getRepositoryScanning();
785         assertTrue( scanning.getKnownContentConsumers().isEmpty() );
786         assertTrue( scanning.getInvalidContentConsumers().isEmpty() );
787         databaseScanning = configuration.getDatabaseScanning();
788         assertTrue( databaseScanning.getCleanupConsumers().isEmpty() );
789         assertTrue( databaseScanning.getUnprocessedConsumers().isEmpty() );
790     }
791 
792     /**
793      * [MRM-582] Remote Repositories with empty <username> and <password> fields shouldn't be created in configuration.
794      */
795     public void testGetConfigurationFixEmptyRemoteRepoUsernamePassword()
796         throws Exception
797     {
798         ArchivaConfiguration archivaConfiguration = (ArchivaConfiguration) lookup(
799                                                                                    ArchivaConfiguration.class.getName(),
800                                                                                    "test-configuration" );
801 
802         Configuration configuration = archivaConfiguration.getConfiguration();
803         assertConfiguration( configuration );
804         assertEquals( "check remote repositories", 2, configuration.getRemoteRepositories().size() );
805 
806         RemoteRepositoryConfiguration repository = (RemoteRepositoryConfiguration) configuration
807             .getRemoteRepositoriesAsMap().get( "maven2-repository.dev.java.net" );
808 
809         assertEquals( "remote repository.url", "https://maven2-repository.dev.java.net/nonav/repository", repository.getUrl() );
810         assertEquals( "remote repository.name", "Java.net Repository for Maven 2", repository.getName() );
811         assertEquals( "remote repository.id", "maven2-repository.dev.java.net", repository.getId() );
812         assertEquals( "remote repository.layout", "default", repository.getLayout() );
813         assertNull( "remote repository.username == null", repository.getUsername() );
814         assertNull( "remote repository.password == null", repository.getPassword() );
815     }
816 }