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