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         ArchivaConfiguration archivaConfiguration =
 190             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-configuration" );
 191
 192         System.setProperty( "org.apache.maven.archiva.webapp.ui.appletFindEnabled", "false" );
 193
 194         try
 195         {
 196             Configuration configuration = archivaConfiguration.getConfiguration();
 197
 198             assertFalse( "check boolean", configuration.getWebapp().getUi().isAppletFindEnabled() );
 199         }
 200         finally
 201         {
 202             System.getProperties().remove( "org.apache.maven.archiva.webapp.ui.appletFindEnabled" );
 203         }
 204     }
 205
 206     public void testStoreConfiguration()
 207         throws Exception
 208     {
 209         File file = getTestFile( "target/test/test-file.xml" );
 210         file.delete();
 211         assertFalse( file.exists() );
 212
 213         // TODO: remove with commons-configuration 1.4
 214         file.getParentFile().mkdirs();
 215         FileUtils.writeStringToFile( file, "<configuration/>", null );
 216
 217         DefaultArchivaConfiguration archivaConfiguration =
 218             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save" );
 219
 220         Configuration configuration = new Configuration();
 221         configuration.setVersion( "1" );
 222         configuration.setWebapp( new WebappConfiguration() );
 223         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 224         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 225
 226         // add a change listener
 227         MockControl control = createConfigurationListenerMockControl();
 228         ConfigurationListener listener = (ConfigurationListener) control.getMock();
 229         archivaConfiguration.addListener( listener );
 230
 231         listener.configurationEvent( new ConfigurationEvent( ConfigurationEvent.SAVED ) );
 232         control.setVoidCallable();
 233
 234         control.replay();
 235
 236         archivaConfiguration.save( configuration );
 237
 238         control.verify();
 239
 240         assertTrue( "Check file exists", file.exists() );
 241
 242         // check it
 243         configuration = archivaConfiguration.getConfiguration();
 244         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 245
 246         // read it back
 247         archivaConfiguration =
 248             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-read-saved" );
 249         configuration = archivaConfiguration.getConfiguration();
 250         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 251     }
 252
 253     private static MockControl createConfigurationListenerMockControl()
 254     {
 255         return MockControl.createControl( ConfigurationListener.class );
 256     }
 257
 258     public void testStoreConfigurationUser()
 259         throws Exception
 260     {
 261         File baseFile = getTestFile( "target/test/test-file.xml" );
 262         baseFile.delete();
 263         assertFalse( baseFile.exists() );
 264
 265         File userFile = getTestFile( "target/test/test-file-user.xml" );
 266         userFile.delete();
 267         assertFalse( userFile.exists() );
 268
 269         userFile.getParentFile().mkdirs();
 270         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
 271
 272         ArchivaConfiguration archivaConfiguration =
 273             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 274
 275         Configuration configuration = new Configuration();
 276         configuration.setWebapp( new WebappConfiguration() );
 277         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 278         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 279
 280         archivaConfiguration.save( configuration );
 281
 282         assertTrue( "Check file exists", userFile.exists() );
 283         assertFalse( "Check file not created", baseFile.exists() );
 284
 285         // check it
 286         configuration = archivaConfiguration.getConfiguration();
 287         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 288     }
 289
 290     public void testStoreConfigurationLoadedFromDefaults()
 291         throws Exception
 292     {
 293         File baseFile = getTestFile( "target/test/test-file.xml" );
 294         baseFile.delete();
 295         assertFalse( baseFile.exists() );
 296
 297         File userFile = getTestFile( "target/test/test-file-user.xml" );
 298         userFile.delete();
 299         assertFalse( userFile.exists() );
 300
 301         ArchivaConfiguration archivaConfiguration =
 302             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 303
 304         Configuration configuration = new Configuration();
 305         configuration.setWebapp( new WebappConfiguration() );
 306         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 307         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 308
 309         // add a change listener
 310         MockControl control = createConfigurationListenerMockControl();
 311         ConfigurationListener listener = (ConfigurationListener) control.getMock();
 312         archivaConfiguration.addListener( listener );
 313
 314         listener.configurationEvent( new ConfigurationEvent( ConfigurationEvent.SAVED ) );
 315         // once from default creation, and again from manual call to save
 316         control.setVoidCallable( 2 );
 317
 318         control.replay();
 319
 320         archivaConfiguration.save( configuration );
 321
 322         control.verify();
 323
 324         assertTrue( "Check file exists", userFile.exists() );
 325         assertFalse( "Check file not created", baseFile.exists() );
 326
 327         // check it
 328         configuration = archivaConfiguration.getConfiguration();
 329         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 330     }
 331
 332     public void testDefaultUserConfigFilename()
 333         throws Exception
 334     {
 335         DefaultArchivaConfiguration archivaConfiguration =
 336             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName() );
 337
 338         assertEquals( System.getProperty( "user.home" ) + "/.m2/archiva.xml",
 339                       archivaConfiguration.getUserConfigFilename() );
 340         assertEquals( System.getProperty( "appserver.base", "${appserver.base}" ) + "/conf/archiva.xml",
 341                       archivaConfiguration.getAltConfigFilename() );
 342     }
 343
 344     public void testStoreConfigurationFallback()
 345         throws Exception
 346     {
 347         File baseFile = getTestFile( "target/test/test-file.xml" );
 348         baseFile.delete();
 349         assertFalse( baseFile.exists() );
 350
 351         File userFile = getTestFile( "target/test/test-file-user.xml" );
 352         userFile.delete();
 353         assertFalse( userFile.exists() );
 354
 355         baseFile.getParentFile().mkdirs();
 356         FileUtils.writeStringToFile( baseFile, "<configuration/>", null );
 357
 358         ArchivaConfiguration archivaConfiguration =
 359             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 360
 361         Configuration configuration = new Configuration();
 362         configuration.setWebapp( new WebappConfiguration() );
 363         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 364         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 365
 366         archivaConfiguration.save( configuration );
 367
 368         assertTrue( "Check file exists", baseFile.exists() );
 369         assertFalse( "Check file not created", userFile.exists() );
 370
 371         // check it
 372         configuration = archivaConfiguration.getConfiguration();
 373         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 374     }
 375
 376     public void testStoreConfigurationFailsWhenReadFromBothLocationsNoLists()
 377         throws Exception
 378     {
 379         File baseFile = getTestFile( "target/test/test-file.xml" );
 380         baseFile.delete();
 381         assertFalse( baseFile.exists() );
 382
 383         File userFile = getTestFile( "target/test/test-file-user.xml" );
 384         userFile.delete();
 385         assertFalse( userFile.exists() );
 386
 387         baseFile.getParentFile().mkdirs();
 388         FileUtils.writeStringToFile( baseFile, "<configuration/>", null );
 389
 390         userFile.getParentFile().mkdirs();
 391         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
 392
 393         ArchivaConfiguration archivaConfiguration =
 394             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 395
 396         Configuration configuration = archivaConfiguration.getConfiguration();
 397         assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 398
 399         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 400
 401         archivaConfiguration.save( configuration );
 402
 403         assertTrue( "Check file exists", baseFile.exists() );
 404         assertEquals( "Check base file is unchanged", "<configuration/>",
 405                       FileUtils.readFileToString( baseFile, null ) );
 406         assertTrue( "Check file exists", userFile.exists() );
 407         assertFalse( "Check base file is changed",
 408                      "<configuration/>".equals( FileUtils.readFileToString( userFile, null ) ) );
 409
 410         // check it
 411         configuration = archivaConfiguration.getConfiguration();
 412         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 413     }
 414
 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/>", null );
 431
 432         ArchivaConfiguration archivaConfiguration =
 433             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 434
 435         Configuration configuration = archivaConfiguration.getConfiguration();
 436         assertTrue( "check value", configuration.getWebapp().getUi().isShowFindArtifacts() );
 437
 438         configuration.getWebapp().getUi().setShowFindArtifacts( false );
 439
 440         archivaConfiguration.save( configuration );
 441
 442         assertTrue( "Check file exists", baseFile.exists() );
 443         assertEquals( "Check base file is unchanged", "<configuration/>",
 444                       FileUtils.readFileToString( baseFile, null ) );
 445         assertTrue( "Check file exists", userFile.exists() );
 446         assertFalse( "Check base file is changed",
 447                      "<configuration/>".equals( FileUtils.readFileToString( userFile, null ) ) );
 448
 449         // check it
 450         configuration = archivaConfiguration.getConfiguration();
 451         assertFalse( "check value", configuration.getWebapp().getUi().isShowFindArtifacts() );
 452     }
 453
 454     public void testStoreConfigurationFailsWhenReadFromBothLocationsAppserverHasLists()
 455         throws Exception
 456     {
 457         File baseFile = getTestFile( "target/test/test-file.xml" );
 458         baseFile.delete();
 459         assertFalse( baseFile.exists() );
 460
 461         File userFile = getTestFile( "target/test/test-file-user.xml" );
 462         userFile.delete();
 463         assertFalse( userFile.exists() );
 464
 465         baseFile.getParentFile().mkdirs();
 466         FileUtils.copyFile( getTestFile( "src/test/conf/conf-base.xml" ), baseFile );
 467
 468         userFile.getParentFile().mkdirs();
 469         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
 470
 471         ArchivaConfiguration archivaConfiguration =
 472             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 473
 474         Configuration configuration = archivaConfiguration.getConfiguration();
 475         assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 476
 477         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 478
 479         try
 480         {
 481             archivaConfiguration.save( configuration );
 482             fail( "Configuration saving should not succeed if it was loaded from two locations" );
 483         }
 484         catch ( IndeterminateConfigurationException e )
 485         {
 486             // check it was reverted
 487             configuration = archivaConfiguration.getConfiguration();
 488             assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 489         }
 490     }
 491
 492     public void testLoadConfigurationFromInvalidBothLocationsOnDisk()
 493         throws Exception
 494     {
 495         ArchivaConfiguration archivaConfiguration =
 496             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-not-allowed-to-write-to-both" );
 497         Configuration config = archivaConfiguration.getConfiguration();
 498
 499         try
 500         {
 501             archivaConfiguration.save( config );
 502             fail( "Should have thrown a RegistryException because the configuration can't be saved." );
 503         }
 504         catch ( RegistryException e )
 505         {
 506             /* expected exception */
 507         }
 508     }
 509
 510     public void testLoadConfigurationFromInvalidUserLocationOnDisk()
 511         throws Exception
 512     {
 513         File testConfDir = getTestFile( "target/test-appserver-base/conf/" );
 514         testConfDir.mkdirs();
 515
 516         ArchivaConfiguration archivaConfiguration =
 517             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-not-allowed-to-write-to-user" );
 518         Configuration config = archivaConfiguration.getConfiguration();
 519         archivaConfiguration.save( config );
 520         // No Exception == test passes.
 521         // Expected Path is: Should not have thrown an exception.
 522     }
 523
 524     public void testConfigurationUpgradeFrom09()
 525         throws Exception
 526     {
 527         ArchivaConfiguration archivaConfiguration =
 528             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-upgrade-09" );
 529
 530         // we just use the defaults when upgrading from 0.9 at this point.
 531         Configuration configuration = archivaConfiguration.getConfiguration();
 532         assertConfiguration( configuration );
 533         assertEquals( "check network proxies", 0, configuration.getNetworkProxies().size() );
 534
 535         ManagedRepositoryConfiguration repository =
 536             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 537
 538         assertEquals( "check managed repositories", "${appserver.base}/data/repositories/internal",
 539                       repository.getLocation() );
 540         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
 541         assertEquals( "check managed repositories", "internal", repository.getId() );
 542         assertEquals( "check managed repositories", "default", repository.getLayout() );
 543         assertTrue( "check managed repositories", repository.isScanned() );
 544     }
 545
 546     public void testAutoDetectV1()
 547         throws Exception
 548     {
 549         // Setup the autodetect-v1.xml file in the target directory (so we can save/load it)
 550         File userFile = getTestFile( "target/test-autodetect-v1/archiva-user.xml" );
 551         userFile.delete();
 552         assertFalse( userFile.exists() );
 553
 554         userFile.getParentFile().mkdirs();
 555         FileUtils.copyFile( getTestFile( "src/test/conf/autodetect-v1.xml" ), userFile );
 556
 557         // Load the original (unconverted) archiva.xml
 558         ArchivaConfiguration archivaConfiguration =
 559             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-autodetect-v1" );
 560
 561         Configuration configuration = archivaConfiguration.getConfiguration();
 562         assertConfiguration( configuration );
 563         assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
 564
 565         ManagedRepositoryConfiguration repository =
 566             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 567
 568         assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
 569                       repository.getLocation() );
 570         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
 571         assertEquals( "check managed repositories", "internal", repository.getId() );
 572         assertEquals( "check managed repositories", "default", repository.getLayout() );
 573         assertTrue( "check managed repositories", repository.isScanned() );
 574
 575         // Test that only 1 set of repositories exist.
 576         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositories().size() );
 577         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositories().size() );
 578         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
 579
 580         // Save the file.
 581         archivaConfiguration.save( configuration );
 582
 583         // Release existing
 584 //      FIXME spring equivalent ?  release( archivaConfiguration );
 585
 586         // Reload.
 587         archivaConfiguration =
 588             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-autodetect-v1" );
 589         configuration = archivaConfiguration.getConfiguration();
 590
 591         // Test that only 1 set of repositories exist.
 592         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositories().size() );
 593         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositoriesAsMap().size() );
 594         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositories().size() );
 595         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositoriesAsMap().size() );
 596         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
 597
 598         String actualXML = FileUtils.readFileToString( userFile, null );
 599         XMLAssert.assertXpathNotExists( "//configuration/repositories/repository", actualXML );
 600         XMLAssert.assertXpathNotExists( "//configuration/repositories", actualXML );
 601     }
 602
 603     public void testArchivaV1()
 604         throws Exception
 605     {
 606         ArchivaConfiguration archivaConfiguration =
 607             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-archiva-v1" );
 608
 609         Configuration configuration = archivaConfiguration.getConfiguration();
 610         assertConfiguration( configuration );
 611         assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
 612
 613         assertEquals( "check managed repositories", 2, configuration.getManagedRepositories().size() );
 614         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
 615
 616         Map<String, ManagedRepositoryConfiguration> map = configuration.getManagedRepositoriesAsMap();
 617
 618         ManagedRepositoryConfiguration repository = map.get( "internal" );
 619         assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
 620                       repository.getLocation() );
 621         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
 622         assertEquals( "check managed repositories", "internal", repository.getId() );
 623         assertEquals( "check managed repositories", "default", repository.getLayout() );
 624         assertTrue( "check managed repositories", repository.isScanned() );
 625         assertFalse( "check managed repositories", repository.isSnapshots() );
 626
 627         repository = map.get( "snapshots" );
 628         assertEquals( "check managed repositories", "${appserver.base}/repositories/snapshots",
 629                       repository.getLocation() );
 630         assertEquals( "check managed repositories", "Archiva Managed Snapshot Repository", repository.getName() );
 631         assertEquals( "check managed repositories", "snapshots", repository.getId() );
 632         assertEquals( "check managed repositories", "default", repository.getLayout() );
 633         assertFalse( "check managed repositories", repository.isScanned() );
 634         assertTrue( "check managed repositories", repository.isSnapshots() );
 635     }
 636
 637     public void testCronExpressionsWithComma()
 638         throws Exception
 639     {
 640         File baseFile = getTestFile( "target/test/test-file.xml" );
 641         baseFile.delete();
 642         assertFalse( baseFile.exists() );
 643
 644         File userFile = getTestFile( "target/test/test-file-user.xml" );
 645         userFile.delete();
 646         assertFalse( userFile.exists() );
 647
 648         baseFile.getParentFile().mkdirs();
 649         FileUtils.copyFile( getTestFile( "src/test/conf/escape-cron-expressions.xml" ), baseFile );
 650
 651         userFile.getParentFile().mkdirs();
 652         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
 653
 654         final ArchivaConfiguration archivaConfiguration =
 655             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-cron-expressions" );
 656
 657         Configuration configuration = archivaConfiguration.getConfiguration();
 658
 659         ManagedRepositoryConfiguration repository =
 660             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 661
 662         assertEquals( "check cron expression", "0 0,30 * * * ?", repository.getRefreshCronExpression().trim() );
 663
 664         configuration.getDatabaseScanning().setCronExpression( "0 0,15 0 * * ?" );
 665
 666         // add a test listener to confirm it doesn't see the escaped format. We don't need to test the number of calls,
 667         // etc. as it's done in other tests
 668         archivaConfiguration.addListener( new ConfigurationListener()
 669         {
 670             public void configurationEvent( ConfigurationEvent event )
 671             {
 672                 assertEquals( ConfigurationEvent.SAVED, event.getType() );
 673
 674                 Configuration configuration = archivaConfiguration.getConfiguration();
 675
 676                 ManagedRepositoryConfiguration repository =
 677                     (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 678
 679                 assertEquals( "check cron expression", "0 0,15 0 * * ?",
 680                               configuration.getDatabaseScanning().getCronExpression() );
 681             }
 682         } );
 683
 684         archivaConfiguration.save( configuration );
 685
 686         configuration = archivaConfiguration.getConfiguration();
 687
 688         assertEquals( "check cron expression", "0 0,15 0 * * ?",
 689                       configuration.getDatabaseScanning().getCronExpression() );
 690
 691         // test for the escape character '\' showing up on repositories.jsp
 692         repository.setRefreshCronExpression( "0 0,20 0 * * ?" );
 693
 694         archivaConfiguration.save( configuration );
 695
 696         repository = archivaConfiguration.getConfiguration().findManagedRepositoryById( "snapshots" );
 697
 698         assertEquals( "check cron expression", "0 0,20 0 * * ?", repository.getRefreshCronExpression() );
 699     }
 700
 701     public void testRemoveLastElements()
 702         throws Exception
 703     {
 704         File baseFile = getTestFile( "target/test/test-file.xml" );
 705         baseFile.delete();
 706         assertFalse( baseFile.exists() );
 707
 708         File userFile = getTestFile( "target/test/test-file-user.xml" );
 709         userFile.delete();
 710         assertFalse( userFile.exists() );
 711
 712         baseFile.getParentFile().mkdirs();
 713         FileUtils.copyFile( getTestFile( "src/test/conf/conf-single-list-elements.xml" ), baseFile );
 714
 715         userFile.getParentFile().mkdirs();
 716         FileUtils.writeStringToFile( userFile, "<configuration/>", null );
 717
 718         ArchivaConfiguration archivaConfiguration =
 719             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-remove-central" );
 720
 721         Configuration configuration = archivaConfiguration.getConfiguration();
 722
 723         RepositoryGroupConfiguration repositoryGroup = ( RepositoryGroupConfiguration ) configuration.getRepositoryGroups().get( 0 );
 724         assertNotNull( repositoryGroup );
 725         configuration.removeRepositoryGroup( repositoryGroup );
 726         assertTrue( configuration.getRepositoryGroups().isEmpty() );
 727
 728         RemoteRepositoryConfiguration repository = configuration.getRemoteRepositoriesAsMap().get( "central" );
 729         assertNotNull( repository );
 730         configuration.removeRemoteRepository( repository );
 731         assertTrue( configuration.getRemoteRepositories().isEmpty() );
 732
 733         ManagedRepositoryConfiguration managedRepository =
 734             configuration.getManagedRepositoriesAsMap().get( "snapshots" );
 735         assertNotNull( managedRepository );
 736         configuration.removeManagedRepository( managedRepository );
 737         assertTrue( configuration.getManagedRepositories().isEmpty() );
 738
 739         ProxyConnectorConfiguration proxyConnector =
 740             (ProxyConnectorConfiguration) configuration.getProxyConnectors().get( 0 );
 741         assertNotNull( proxyConnector );
 742         configuration.removeProxyConnector( proxyConnector );
 743         assertTrue( configuration.getProxyConnectors().isEmpty() );
 744
 745         NetworkProxyConfiguration networkProxy = configuration.getNetworkProxiesAsMap().get( "proxy" );
 746         assertNotNull( networkProxy );
 747         configuration.removeNetworkProxy( networkProxy );
 748         assertTrue( configuration.getNetworkProxies().isEmpty() );
 749
 750         LegacyArtifactPath path = (LegacyArtifactPath) configuration.getLegacyArtifactPaths().get( 0 );
 751         assertNotNull( path );
 752         configuration.removeLegacyArtifactPath( path );
 753         assertTrue( configuration.getLegacyArtifactPaths().isEmpty() );
 754
 755         RepositoryScanningConfiguration scanning = configuration.getRepositoryScanning();
 756         String consumer = (String) scanning.getKnownContentConsumers().get( 0 );
 757         assertNotNull( consumer );
 758         scanning.removeKnownContentConsumer( consumer );
 759         assertTrue( scanning.getKnownContentConsumers().isEmpty() );
 760         consumer = (String) scanning.getInvalidContentConsumers().get( 0 );
 761         assertNotNull( consumer );
 762         scanning.removeInvalidContentConsumer( consumer );
 763         assertTrue( scanning.getInvalidContentConsumers().isEmpty() );
 764
 765         DatabaseScanningConfiguration databaseScanning = configuration.getDatabaseScanning();
 766         consumer = (String) databaseScanning.getCleanupConsumers().get( 0 );
 767         assertNotNull( consumer );
 768         databaseScanning.removeCleanupConsumer( consumer );
 769         assertTrue( databaseScanning.getCleanupConsumers().isEmpty() );
 770         consumer = (String) databaseScanning.getUnprocessedConsumers().get( 0 );
 771         assertNotNull( consumer );
 772         databaseScanning.removeUnprocessedConsumer( consumer );
 773         assertTrue( databaseScanning.getUnprocessedConsumers().isEmpty() );
 774
 775         archivaConfiguration.save( configuration );
 776
 777         archivaConfiguration =
 778             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-read-saved" );
 779         configuration = archivaConfiguration.getConfiguration();
 780         assertNull( configuration.getRemoteRepositoriesAsMap().get( "central" ) );
 781         assertTrue( configuration.getRepositoryGroups().isEmpty() );
 782         assertNull( configuration.getManagedRepositoriesAsMap().get( "snapshots" ) );
 783         assertTrue( configuration.getProxyConnectors().isEmpty() );
 784         assertNull( configuration.getNetworkProxiesAsMap().get( "proxy" ) );
 785         assertTrue( configuration.getLegacyArtifactPaths().isEmpty() );
 786         scanning = configuration.getRepositoryScanning();
 787         assertTrue( scanning.getKnownContentConsumers().isEmpty() );
 788         assertTrue( scanning.getInvalidContentConsumers().isEmpty() );
 789         databaseScanning = configuration.getDatabaseScanning();
 790         assertTrue( databaseScanning.getCleanupConsumers().isEmpty() );
 791         assertTrue( databaseScanning.getUnprocessedConsumers().isEmpty() );
 792     }
 793
 794     /**
 795      * [MRM-582] Remote Repositories with empty <username> and <password> fields shouldn't be created in configuration.
 796      */
 797     public void testGetConfigurationFixEmptyRemoteRepoUsernamePassword()
 798         throws Exception
 799     {
 800         ArchivaConfiguration archivaConfiguration = (ArchivaConfiguration) lookup(
 801                                                                                    ArchivaConfiguration.class.getName(),
 802                                                                                    "test-configuration" );
 803
 804         Configuration configuration = archivaConfiguration.getConfiguration();
 805         assertConfiguration( configuration );
 806         assertEquals( "check remote repositories", 2, configuration.getRemoteRepositories().size() );
 807
 808         RemoteRepositoryConfiguration repository = (RemoteRepositoryConfiguration) configuration
 809             .getRemoteRepositoriesAsMap().get( "maven2-repository.dev.java.net" );
 810
 811         assertEquals( "remote repository.url", "https://maven2-repository.dev.java.net/nonav/repository", repository.getUrl() );
 812         assertEquals( "remote repository.name", "Java.net Repository for Maven 2", repository.getName() );
 813         assertEquals( "remote repository.id", "maven2-repository.dev.java.net", repository.getId() );
 814         assertEquals( "remote repository.layout", "default", repository.getLayout() );
 815         assertNull( "remote repository.username == null", repository.getUsername() );
 816         assertNull( "remote repository.password == null", repository.getPassword() );
 817     }
 818 }