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

   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                 ManagedRepositoryConfiguration repository =
 678                     (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 679
 680                 assertEquals( "check cron expression", "0 0,15 0 * * ?",
 681                               configuration.getDatabaseScanning().getCronExpression() );
 682             }
 683         } );
 684
 685         archivaConfiguration.save( configuration );
 686
 687         configuration = archivaConfiguration.getConfiguration();
 688
 689         assertEquals( "check cron expression", "0 0,15 0 * * ?",
 690                       configuration.getDatabaseScanning().getCronExpression() );
 691
 692         // test for the escape character '\' showing up on repositories.jsp
 693         repository.setRefreshCronExpression( "0 0,20 0 * * ?" );
 694
 695         archivaConfiguration.save( configuration );
 696
 697         repository = archivaConfiguration.getConfiguration().findManagedRepositoryById( "snapshots" );
 698
 699         assertEquals( "check cron expression", "0 0,20 0 * * ?", repository.getRefreshCronExpression() );
 700     }
 701
 702     public void testRemoveLastElements()
 703         throws Exception
 704     {
 705         File baseFile = getTestFile( "target/test/test-file.xml" );
 706         baseFile.delete();
 707         assertFalse( baseFile.exists() );
 708
 709         File userFile = getTestFile( "target/test/test-file-user.xml" );
 710         userFile.delete();
 711         assertFalse( userFile.exists() );
 712
 713         baseFile.getParentFile().mkdirs();
 714         FileUtils.copyFile( getTestFile( "src/test/conf/conf-single-list-elements.xml" ), baseFile );
 715
 716         userFile.getParentFile().mkdirs();
 717         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
 718
 719         ArchivaConfiguration archivaConfiguration =
 720             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-remove-central" );
 721
 722         Configuration configuration = archivaConfiguration.getConfiguration();
 723
 724         RepositoryGroupConfiguration repositoryGroup = ( RepositoryGroupConfiguration ) configuration.getRepositoryGroups().get( 0 );
 725         assertNotNull( repositoryGroup );
 726         configuration.removeRepositoryGroup( repositoryGroup );
 727         assertTrue( configuration.getRepositoryGroups().isEmpty() );
 728
 729         RemoteRepositoryConfiguration repository = configuration.getRemoteRepositoriesAsMap().get( "central" );
 730         assertNotNull( repository );
 731         configuration.removeRemoteRepository( repository );
 732         assertTrue( configuration.getRemoteRepositories().isEmpty() );
 733
 734         ManagedRepositoryConfiguration managedRepository =
 735             configuration.getManagedRepositoriesAsMap().get( "snapshots" );
 736         assertNotNull( managedRepository );
 737         configuration.removeManagedRepository( managedRepository );
 738         assertTrue( configuration.getManagedRepositories().isEmpty() );
 739
 740         ProxyConnectorConfiguration proxyConnector =
 741             (ProxyConnectorConfiguration) configuration.getProxyConnectors().get( 0 );
 742         assertNotNull( proxyConnector );
 743         configuration.removeProxyConnector( proxyConnector );
 744         assertTrue( configuration.getProxyConnectors().isEmpty() );
 745
 746         NetworkProxyConfiguration networkProxy = configuration.getNetworkProxiesAsMap().get( "proxy" );
 747         assertNotNull( networkProxy );
 748         configuration.removeNetworkProxy( networkProxy );
 749         assertTrue( configuration.getNetworkProxies().isEmpty() );
 750
 751         LegacyArtifactPath path = (LegacyArtifactPath) configuration.getLegacyArtifactPaths().get( 0 );
 752         assertNotNull( path );
 753         configuration.removeLegacyArtifactPath( path );
 754         assertTrue( configuration.getLegacyArtifactPaths().isEmpty() );
 755
 756         RepositoryScanningConfiguration scanning = configuration.getRepositoryScanning();
 757         String consumer = (String) scanning.getKnownContentConsumers().get( 0 );
 758         assertNotNull( consumer );
 759         scanning.removeKnownContentConsumer( consumer );
 760         assertTrue( scanning.getKnownContentConsumers().isEmpty() );
 761         consumer = (String) scanning.getInvalidContentConsumers().get( 0 );
 762         assertNotNull( consumer );
 763         scanning.removeInvalidContentConsumer( consumer );
 764         assertTrue( scanning.getInvalidContentConsumers().isEmpty() );
 765
 766         DatabaseScanningConfiguration databaseScanning = configuration.getDatabaseScanning();
 767         consumer = (String) databaseScanning.getCleanupConsumers().get( 0 );
 768         assertNotNull( consumer );
 769         databaseScanning.removeCleanupConsumer( consumer );
 770         assertTrue( databaseScanning.getCleanupConsumers().isEmpty() );
 771         consumer = (String) databaseScanning.getUnprocessedConsumers().get( 0 );
 772         assertNotNull( consumer );
 773         databaseScanning.removeUnprocessedConsumer( consumer );
 774         assertTrue( databaseScanning.getUnprocessedConsumers().isEmpty() );
 775
 776         archivaConfiguration.save( configuration );
 777
 778         archivaConfiguration =
 779             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-read-saved" );
 780         configuration = archivaConfiguration.getConfiguration();
 781         assertNull( configuration.getRemoteRepositoriesAsMap().get( "central" ) );
 782         assertTrue( configuration.getRepositoryGroups().isEmpty() );
 783         assertNull( configuration.getManagedRepositoriesAsMap().get( "snapshots" ) );
 784         assertTrue( configuration.getProxyConnectors().isEmpty() );
 785         assertNull( configuration.getNetworkProxiesAsMap().get( "proxy" ) );
 786         assertTrue( configuration.getLegacyArtifactPaths().isEmpty() );
 787         scanning = configuration.getRepositoryScanning();
 788         assertTrue( scanning.getKnownContentConsumers().isEmpty() );
 789         assertTrue( scanning.getInvalidContentConsumers().isEmpty() );
 790         databaseScanning = configuration.getDatabaseScanning();
 791         assertTrue( databaseScanning.getCleanupConsumers().isEmpty() );
 792         assertTrue( databaseScanning.getUnprocessedConsumers().isEmpty() );
 793     }
 794
 795     /**
 796      * [MRM-582] Remote Repositories with empty <username> and <password> fields shouldn't be created in configuration.
 797      */
 798     public void testGetConfigurationFixEmptyRemoteRepoUsernamePassword()
 799         throws Exception
 800     {
 801         ArchivaConfiguration archivaConfiguration = (ArchivaConfiguration) lookup(
 802                                                                                    ArchivaConfiguration.class.getName(),
 803                                                                                    "test-configuration" );
 804
 805         Configuration configuration = archivaConfiguration.getConfiguration();
 806         assertConfiguration( configuration );
 807         assertEquals( "check remote repositories", 2, configuration.getRemoteRepositories().size() );
 808
 809         RemoteRepositoryConfiguration repository = (RemoteRepositoryConfiguration) configuration
 810             .getRemoteRepositoriesAsMap().get( "maven2-repository.dev.java.net" );
 811
 812         assertEquals( "remote repository.url", "https://maven2-repository.dev.java.net/nonav/repository", repository.getUrl() );
 813         assertEquals( "remote repository.name", "Java.net Repository for Maven 2", repository.getName() );
 814         assertEquals( "remote repository.id", "maven2-repository.dev.java.net", repository.getId() );
 815         assertEquals( "remote repository.layout", "default", repository.getLayout() );
 816         assertNull( "remote repository.username == null", repository.getUsername() );
 817         assertNull( "remote repository.password == null", repository.getPassword() );
 818     }
 819 }