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