source.dussan.org Git - archiva.git/blob

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