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 org.codehaus.plexus.PlexusTestCase;
  23 import org.codehaus.plexus.registry.Registry;
  24 import org.codehaus.plexus.registry.RegistryException;
  25 import org.codehaus.plexus.util.FileUtils;
  26 import org.easymock.MockControl;
  27
  28 import java.io.File;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 /**
  33  * Test the configuration store.
  34  *
  35  * @author <a href="mailto:brett@apache.org">Brett Porter</a>
  36  */
  37 public class ArchivaConfigurationTest
  38     extends PlexusTestCase
  39 {
  40     @SuppressWarnings("unused")
  41     private Registry registry;
  42
  43     protected void setUp()
  44         throws Exception
  45     {
  46         super.setUp();
  47
  48         registry = (Registry) lookup( Registry.ROLE, "commons-configuration" );
  49     }
  50
  51     public void testGetConfigurationFromRegistryWithASingleNamedConfigurationResource()
  52         throws Exception
  53     {
  54         ArchivaConfiguration archivaConfiguration =
  55             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-configuration" );
  56
  57         Configuration configuration = archivaConfiguration.getConfiguration();
  58         assertConfiguration( configuration );
  59         assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
  60
  61         ManagedRepositoryConfiguration repository =
  62             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
  63
  64         assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
  65                       repository.getLocation() );
  66         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
  67         assertEquals( "check managed repositories", "internal", repository.getId() );
  68         assertEquals( "check managed repositories", "default", repository.getLayout() );
  69         assertTrue( "check managed repositories", repository.isScanned() );
  70     }
  71
  72     public void testGetConfigurationFromDefaults()
  73         throws Exception
  74     {
  75         ArchivaConfiguration archivaConfiguration =
  76             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-defaults" );
  77
  78         Configuration configuration = archivaConfiguration.getConfiguration();
  79         assertConfiguration( configuration );
  80         assertEquals( "check network proxies", 0, configuration.getNetworkProxies().size() );
  81
  82         ManagedRepositoryConfiguration repository =
  83             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
  84
  85         assertEquals( "check managed repositories", "${appserver.base}/data/repositories/internal",
  86                       repository.getLocation() );
  87         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
  88         assertEquals( "check managed repositories", "internal", repository.getId() );
  89         assertEquals( "check managed repositories", "default", repository.getLayout() );
  90         assertTrue( "check managed repositories", repository.isScanned() );
  91     }
  92
  93     /**
  94      * Ensures that the provided configuration matches the details present in the archiva-default.xml file.
  95      */
  96     private void assertConfiguration( Configuration configuration )
  97         throws Exception
  98     {
  99         FileTypes filetypes = (FileTypes) lookup( FileTypes.class.getName() );
 100
 101         assertEquals( "check repositories", 2, configuration.getManagedRepositories().size() );
 102         assertEquals( "check repositories", 2, configuration.getRemoteRepositories().size() );
 103         assertEquals( "check proxy connectors", 2, configuration.getProxyConnectors().size() );
 104
 105         RepositoryScanningConfiguration repoScanning = configuration.getRepositoryScanning();
 106         assertNotNull( "check repository scanning", repoScanning );
 107         assertEquals( "check file types", 4, repoScanning.getFileTypes().size() );
 108         assertEquals( "check known consumers", 9, repoScanning.getKnownContentConsumers().size() );
 109         assertEquals( "check invalid consumers", 1, repoScanning.getInvalidContentConsumers().size() );
 110
 111         List<String> patterns = filetypes.getFileTypePatterns( "artifacts" );
 112         assertNotNull( "check 'artifacts' file type", patterns );
 113         assertEquals( "check 'artifacts' patterns", 13, patterns.size() );
 114
 115         DatabaseScanningConfiguration dbScanning = configuration.getDatabaseScanning();
 116         assertNotNull( "check database scanning", dbScanning );
 117         assertEquals( "check unprocessed consumers", 6, dbScanning.getUnprocessedConsumers().size() );
 118         assertEquals( "check cleanup consumers", 3, dbScanning.getCleanupConsumers().size() );
 119
 120         WebappConfiguration webapp = configuration.getWebapp();
 121         assertNotNull( "check webapp", webapp );
 122
 123         UserInterfaceOptions ui = webapp.getUi();
 124         assertNotNull( "check webapp ui", ui );
 125         assertTrue( "check showFindArtifacts", ui.isShowFindArtifacts() );
 126         assertTrue( "check appletFindEnabled", ui.isAppletFindEnabled() );
 127     }
 128
 129     public void testGetConfigurationFromRegistryWithTwoConfigurationResources()
 130         throws Exception
 131     {
 132         ArchivaConfiguration archivaConfiguration =
 133             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-configuration-both" );
 134
 135         Configuration configuration = archivaConfiguration.getConfiguration();
 136
 137         // from base
 138         assertEquals( "check repositories", 2, configuration.getManagedRepositories().size() );
 139         assertEquals( "check repositories", 2, configuration.getRemoteRepositories().size() );
 140         // from user
 141         assertEquals( "check proxy connectors", 2, configuration.getProxyConnectors().size() );
 142
 143         WebappConfiguration webapp = configuration.getWebapp();
 144         assertNotNull( "check webapp", webapp );
 145
 146         UserInterfaceOptions ui = webapp.getUi();
 147         assertNotNull( "check webapp ui", ui );
 148         // from base
 149         assertFalse( "check showFindArtifacts", ui.isShowFindArtifacts() );
 150         // from user
 151         assertFalse( "check appletFindEnabled", ui.isAppletFindEnabled() );
 152     }
 153
 154     public void testGetConfigurationSystemOverride()
 155         throws Exception
 156     {
 157         ArchivaConfiguration archivaConfiguration =
 158             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-configuration" );
 159
 160         System.setProperty( "org.apache.maven.archiva.webapp.ui.appletFindEnabled", "false" );
 161
 162         try
 163         {
 164             Configuration configuration = archivaConfiguration.getConfiguration();
 165
 166             assertFalse( "check boolean", configuration.getWebapp().getUi().isAppletFindEnabled() );
 167         }
 168         finally
 169         {
 170             System.getProperties().remove( "org.apache.maven.archiva.webapp.ui.appletFindEnabled" );
 171         }
 172     }
 173
 174     public void testStoreConfiguration()
 175         throws Exception
 176     {
 177         File file = getTestFile( "target/test/test-file.xml" );
 178         file.delete();
 179         assertFalse( file.exists() );
 180
 181         // TODO: remove with commons-configuration 1.4
 182         file.getParentFile().mkdirs();
 183         FileUtils.fileWrite( file.getAbsolutePath(), "<configuration/>" );
 184
 185         DefaultArchivaConfiguration archivaConfiguration =
 186             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save" );
 187
 188         Configuration configuration = new Configuration();
 189         configuration.setVersion( "1" );
 190         configuration.setWebapp( new WebappConfiguration() );
 191         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 192         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 193
 194         // add a change listener
 195         MockControl control = createConfigurationListenerMockControl();
 196         ConfigurationListener listener = (ConfigurationListener) control.getMock();
 197         archivaConfiguration.addListener( listener );
 198
 199         listener.configurationEvent( new ConfigurationEvent( ConfigurationEvent.SAVED ) );
 200         control.setVoidCallable();
 201
 202         control.replay();
 203
 204         archivaConfiguration.save( configuration );
 205
 206         control.verify();
 207
 208         assertTrue( "Check file exists", file.exists() );
 209
 210         // check it
 211         configuration = archivaConfiguration.getConfiguration();
 212         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 213
 214         // read it back
 215         archivaConfiguration =
 216             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-read-saved" );
 217         configuration = archivaConfiguration.getConfiguration();
 218         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 219     }
 220
 221     private static MockControl createConfigurationListenerMockControl()
 222     {
 223         MockControl control = MockControl.createControl( ConfigurationListener.class );
 224         return control;
 225     }
 226
 227     public void testStoreConfigurationUser()
 228         throws Exception
 229     {
 230         File baseFile = getTestFile( "target/test/test-file.xml" );
 231         baseFile.delete();
 232         assertFalse( baseFile.exists() );
 233
 234         File userFile = getTestFile( "target/test/test-file-user.xml" );
 235         userFile.delete();
 236         assertFalse( userFile.exists() );
 237
 238         userFile.getParentFile().mkdirs();
 239         FileUtils.fileWrite( userFile.getAbsolutePath(), "<configuration/>" );
 240
 241         ArchivaConfiguration archivaConfiguration =
 242             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 243
 244         Configuration configuration = new Configuration();
 245         configuration.setWebapp( new WebappConfiguration() );
 246         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 247         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 248
 249         archivaConfiguration.save( configuration );
 250
 251         assertTrue( "Check file exists", userFile.exists() );
 252         assertFalse( "Check file not created", baseFile.exists() );
 253
 254         // check it
 255         configuration = archivaConfiguration.getConfiguration();
 256         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 257     }
 258
 259     public void testStoreConfigurationLoadedFromDefaults()
 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         ArchivaConfiguration archivaConfiguration =
 271             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 272
 273         Configuration configuration = new Configuration();
 274         configuration.setWebapp( new WebappConfiguration() );
 275         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 276         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 277
 278         // add a change listener
 279         MockControl control = createConfigurationListenerMockControl();
 280         ConfigurationListener listener = (ConfigurationListener) control.getMock();
 281         archivaConfiguration.addListener( listener );
 282
 283         listener.configurationEvent( new ConfigurationEvent( ConfigurationEvent.SAVED ) );
 284         // once from default creation, and again from manual call to save
 285         control.setVoidCallable( 2 );
 286
 287         control.replay();
 288
 289         archivaConfiguration.save( configuration );
 290
 291         control.verify();
 292
 293         assertTrue( "Check file exists", userFile.exists() );
 294         assertFalse( "Check file not created", baseFile.exists() );
 295
 296         // check it
 297         configuration = archivaConfiguration.getConfiguration();
 298         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 299     }
 300
 301     public void testDefaultUserConfigFilename()
 302         throws Exception
 303     {
 304         DefaultArchivaConfiguration archivaConfiguration =
 305             (DefaultArchivaConfiguration) lookup( ArchivaConfiguration.class.getName() );
 306
 307         assertEquals( System.getProperty( "user.home" ) + "/.m2/archiva.xml",
 308                       archivaConfiguration.getUserConfigFilename() );
 309         assertEquals( System.getProperty( "appserver.base", "${appserver.base}" ) + "/conf/archiva.xml",
 310                       archivaConfiguration.getAltConfigFilename() );
 311     }
 312
 313     public void testStoreConfigurationFallback()
 314         throws Exception
 315     {
 316         File baseFile = getTestFile( "target/test/test-file.xml" );
 317         baseFile.delete();
 318         assertFalse( baseFile.exists() );
 319
 320         File userFile = getTestFile( "target/test/test-file-user.xml" );
 321         userFile.delete();
 322         assertFalse( userFile.exists() );
 323
 324         baseFile.getParentFile().mkdirs();
 325         FileUtils.fileWrite( baseFile.getAbsolutePath(), "<configuration/>" );
 326
 327         ArchivaConfiguration archivaConfiguration =
 328             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 329
 330         Configuration configuration = new Configuration();
 331         configuration.setWebapp( new WebappConfiguration() );
 332         configuration.getWebapp().setUi( new UserInterfaceOptions() );
 333         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 334
 335         archivaConfiguration.save( configuration );
 336
 337         assertTrue( "Check file exists", baseFile.exists() );
 338         assertFalse( "Check file not created", userFile.exists() );
 339
 340         // check it
 341         configuration = archivaConfiguration.getConfiguration();
 342         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 343     }
 344
 345     public void testStoreConfigurationFailsWhenReadFromBothLocationsNoLists()
 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.fileWrite( baseFile.getAbsolutePath(), "<configuration/>" );
 358
 359         userFile.getParentFile().mkdirs();
 360         FileUtils.fileWrite( userFile.getAbsolutePath(), "<configuration/>" );
 361
 362         ArchivaConfiguration archivaConfiguration =
 363             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 364
 365         Configuration configuration = archivaConfiguration.getConfiguration();
 366         assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 367
 368         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 369
 370         archivaConfiguration.save( configuration );
 371
 372         assertTrue( "Check file exists", baseFile.exists() );
 373         assertEquals( "Check base file is unchanged", "<configuration/>",
 374                       FileUtils.fileRead( baseFile.getAbsolutePath() ) );
 375         assertTrue( "Check file exists", userFile.exists() );
 376         assertFalse( "Check base file is changed",
 377                      "<configuration/>".equals( FileUtils.fileRead( userFile.getAbsolutePath() ) ) );
 378
 379         // check it
 380         configuration = archivaConfiguration.getConfiguration();
 381         assertFalse( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 382     }
 383
 384     public void testStoreConfigurationFailsWhenReadFromBothLocationsUserHasLists()
 385         throws Exception
 386     {
 387         File baseFile = getTestFile( "target/test/test-file.xml" );
 388         baseFile.delete();
 389         assertFalse( baseFile.exists() );
 390
 391         File userFile = getTestFile( "target/test/test-file-user.xml" );
 392         userFile.delete();
 393         assertFalse( userFile.exists() );
 394
 395         userFile.getParentFile().mkdirs();
 396         FileUtils.copyFile( getTestFile( "src/test/conf/conf-user.xml" ), userFile );
 397
 398         baseFile.getParentFile().mkdirs();
 399         FileUtils.fileWrite( baseFile.getAbsolutePath(), "<configuration/>" );
 400
 401         ArchivaConfiguration archivaConfiguration =
 402             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 403
 404         Configuration configuration = archivaConfiguration.getConfiguration();
 405         assertTrue( "check value", configuration.getWebapp().getUi().isShowFindArtifacts() );
 406
 407         configuration.getWebapp().getUi().setShowFindArtifacts( false );
 408
 409         archivaConfiguration.save( configuration );
 410
 411         assertTrue( "Check file exists", baseFile.exists() );
 412         assertEquals( "Check base file is unchanged", "<configuration/>",
 413                       FileUtils.fileRead( baseFile.getAbsolutePath() ) );
 414         assertTrue( "Check file exists", userFile.exists() );
 415         assertFalse( "Check base file is changed",
 416                      "<configuration/>".equals( FileUtils.fileRead( userFile.getAbsolutePath() ) ) );
 417
 418         // check it
 419         configuration = archivaConfiguration.getConfiguration();
 420         assertFalse( "check value", configuration.getWebapp().getUi().isShowFindArtifacts() );
 421     }
 422
 423     public void testStoreConfigurationFailsWhenReadFromBothLocationsAppserverHasLists()
 424         throws Exception
 425     {
 426         File baseFile = getTestFile( "target/test/test-file.xml" );
 427         baseFile.delete();
 428         assertFalse( baseFile.exists() );
 429
 430         File userFile = getTestFile( "target/test/test-file-user.xml" );
 431         userFile.delete();
 432         assertFalse( userFile.exists() );
 433
 434         baseFile.getParentFile().mkdirs();
 435         FileUtils.copyFile( getTestFile( "src/test/conf/conf-base.xml" ), baseFile );
 436
 437         userFile.getParentFile().mkdirs();
 438         FileUtils.fileWrite( userFile.getAbsolutePath(), "<configuration/>" );
 439
 440         ArchivaConfiguration archivaConfiguration =
 441             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-save-user" );
 442
 443         Configuration configuration = archivaConfiguration.getConfiguration();
 444         assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 445
 446         configuration.getWebapp().getUi().setAppletFindEnabled( false );
 447
 448         try
 449         {
 450             archivaConfiguration.save( configuration );
 451             fail( "Configuration saving should not succeed if it was loaded from two locations" );
 452         }
 453         catch ( IndeterminateConfigurationException e )
 454         {
 455             // check it was reverted
 456             configuration = archivaConfiguration.getConfiguration();
 457             assertTrue( "check value", configuration.getWebapp().getUi().isAppletFindEnabled() );
 458         }
 459     }
 460
 461     public void testLoadConfigurationFromInvalidBothLocationsOnDisk() throws Exception
 462     {
 463         ArchivaConfiguration archivaConfiguration = (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(),
 464                                                                                    "test-not-allowed-to-write-to-both" );
 465         Configuration config = archivaConfiguration.getConfiguration();
 466
 467         try
 468         {
 469             archivaConfiguration.save( config );
 470             fail( "Should have thrown a RegistryException because the configuration can't be saved." );
 471         }
 472         catch ( RegistryException e )
 473         {
 474             /* expected exception */
 475         }
 476     }
 477
 478     public void testLoadConfigurationFromInvalidUserLocationOnDisk() throws Exception
 479     {
 480         File testConfDir = getTestFile( "target/test-appserver-base/conf/" );
 481         testConfDir.mkdirs();
 482
 483         ArchivaConfiguration archivaConfiguration = (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(),
 484                                                                                    "test-not-allowed-to-write-to-user" );
 485         Configuration config = archivaConfiguration.getConfiguration();
 486         archivaConfiguration.save( config );
 487         // No Exception == test passes.
 488         // Expected Path is: Should not have thrown an exception.
 489     }
 490
 491     public void testConfigurationUpgradeFrom09()
 492         throws Exception
 493     {
 494         ArchivaConfiguration archivaConfiguration =
 495             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-upgrade-09" );
 496
 497         // we just use the defaults when upgrading from 0.9 at this point.
 498         Configuration configuration = archivaConfiguration.getConfiguration();
 499         assertConfiguration( configuration );
 500         assertEquals( "check network proxies", 0, configuration.getNetworkProxies().size() );
 501
 502         ManagedRepositoryConfiguration repository =
 503             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 504
 505         assertEquals( "check managed repositories", "${appserver.base}/data/repositories/internal",
 506                       repository.getLocation() );
 507         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
 508         assertEquals( "check managed repositories", "internal", repository.getId() );
 509         assertEquals( "check managed repositories", "default", repository.getLayout() );
 510         assertTrue( "check managed repositories", repository.isScanned() );
 511     }
 512
 513     public void testAutoDetectV1()
 514         throws Exception
 515     {
 516         // Setup the autodetect-v1.xml file in the target directory (so we can save/load it)
 517         File userFile = getTestFile( "target/test-autodetect-v1/archiva-user.xml" );
 518         userFile.delete();
 519         assertFalse( userFile.exists() );
 520
 521         userFile.getParentFile().mkdirs();
 522         FileUtils.copyFile( getTestFile( "src/test/conf/autodetect-v1.xml" ), userFile );
 523
 524         // Load the original (unconverted) archiva.xml
 525         ArchivaConfiguration archivaConfiguration =
 526             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-autodetect-v1" );
 527
 528         Configuration configuration = archivaConfiguration.getConfiguration();
 529         assertConfiguration( configuration );
 530         assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
 531
 532         ManagedRepositoryConfiguration repository =
 533             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 534
 535         assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
 536                       repository.getLocation() );
 537         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
 538         assertEquals( "check managed repositories", "internal", repository.getId() );
 539         assertEquals( "check managed repositories", "default", repository.getLayout() );
 540         assertTrue( "check managed repositories", repository.isScanned() );
 541
 542         // Test that only 1 set of repositories exist.
 543         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositories().size() );
 544         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositories().size() );
 545         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
 546
 547         // Save the file.
 548         archivaConfiguration.save( configuration );
 549
 550         // Release existing
 551         release( archivaConfiguration );
 552
 553         // Reload.
 554         archivaConfiguration =
 555             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-autodetect-v1" );
 556
 557         // Test that only 1 set of repositories exist.
 558         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositories().size() );
 559         assertEquals( "check managed repositories size.", 2, configuration.getManagedRepositoriesAsMap().size() );
 560         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositories().size() );
 561         assertEquals( "check remote repositories size.", 2, configuration.getRemoteRepositoriesAsMap().size() );
 562         assertEquals( "check v1 repositories size.", 0, configuration.getRepositories().size() );
 563
 564         /* FIXME: can't get rid of old v1 <repositories> section programatically.
 565         String actualXML = FileUtils.fileRead( userFile );
 566         XMLAssert.assertXpathNotExists( "//configuration/repositories/repository", actualXML );
 567         XMLAssert.assertXpathNotExists( "//configuration/repositories", actualXML );
 568          */
 569     }
 570
 571     public void testArchivaV1()
 572         throws Exception
 573     {
 574         ArchivaConfiguration archivaConfiguration =
 575             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-archiva-v1" );
 576
 577         Configuration configuration = archivaConfiguration.getConfiguration();
 578         assertConfiguration( configuration );
 579         assertEquals( "check network proxies", 1, configuration.getNetworkProxies().size() );
 580
 581         assertEquals( "check managed repositories", 2, configuration.getManagedRepositories().size() );
 582
 583         Map<String, ManagedRepositoryConfiguration> map = configuration.getManagedRepositoriesAsMap();
 584
 585         ManagedRepositoryConfiguration repository = map.get( "internal" );
 586         assertEquals( "check managed repositories", "${appserver.base}/repositories/internal",
 587                       repository.getLocation() );
 588         assertEquals( "check managed repositories", "Archiva Managed Internal Repository", repository.getName() );
 589         assertEquals( "check managed repositories", "internal", repository.getId() );
 590         assertEquals( "check managed repositories", "default", repository.getLayout() );
 591         assertTrue( "check managed repositories", repository.isScanned() );
 592         assertFalse( "check managed repositories", repository.isSnapshots() );
 593
 594         repository = map.get( "snapshots" );
 595         assertEquals( "check managed repositories", "${appserver.base}/repositories/snapshots",
 596                       repository.getLocation() );
 597         assertEquals( "check managed repositories", "Archiva Managed Snapshot Repository", repository.getName() );
 598         assertEquals( "check managed repositories", "snapshots", repository.getId() );
 599         assertEquals( "check managed repositories", "default", repository.getLayout() );
 600         assertFalse( "check managed repositories", repository.isScanned() );
 601         assertTrue( "check managed repositories", repository.isSnapshots() );
 602     }
 603
 604     public void testCronExpressionsWithComma()
 605         throws Exception
 606     {
 607         File baseFile = getTestFile( "target/test/test-file.xml" );
 608         baseFile.delete();
 609         assertFalse( baseFile.exists() );
 610
 611         File userFile = getTestFile( "target/test/test-file-user.xml" );
 612         userFile.delete();
 613         assertFalse( userFile.exists() );
 614
 615         baseFile.getParentFile().mkdirs();
 616         FileUtils.copyFile( getTestFile( "src/test/conf/escape-cron-expressions.xml" ), baseFile );
 617
 618         userFile.getParentFile().mkdirs();
 619         FileUtils.fileWrite( userFile.getAbsolutePath(), "<configuration/>" );
 620
 621         ArchivaConfiguration archivaConfiguration =
 622             (ArchivaConfiguration) lookup( ArchivaConfiguration.class.getName(), "test-cron-expressions" );
 623
 624         Configuration configuration = archivaConfiguration.getConfiguration();
 625
 626         ManagedRepositoryConfiguration repository =
 627             (ManagedRepositoryConfiguration) configuration.getManagedRepositories().get( 0 );
 628
 629         assertEquals( "check cron expression", "0 0,30 * * ?", repository.getRefreshCronExpression().trim() );
 630
 631         configuration.getDatabaseScanning().setCronExpression( "0 0,15 0 * * ?" );
 632
 633         archivaConfiguration.save( configuration );
 634
 635         configuration = archivaConfiguration.getConfiguration();
 636
 637         assertEquals( "check cron expression", "0 0,15 0 * * ?",
 638                       configuration.getDatabaseScanning().getCronExpression() );
 639
 640         // test for the escape character '\' showing up on repositories.jsp
 641         repository.setRefreshCronExpression( "0 0,20 0 * * ?" );
 642
 643         archivaConfiguration.save( configuration );
 644
 645         repository = archivaConfiguration.getConfiguration().findManagedRepositoryById( "snapshots" );
 646
 647         assertEquals( "check cron expression", "0 0,20 0 * * ?", repository.getRefreshCronExpression() );
 648     }
 649 }