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

   1 package org.apache.archiva.web.action.admin.connectors.proxy;
   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 com.opensymphony.xwork2.Action;
  23 import org.apache.archiva.admin.model.beans.ProxyConnector;
  24 import org.apache.archiva.admin.repository.managed.DefaultManagedRepositoryAdmin;
  25 import org.apache.archiva.admin.repository.proxyconnector.DefaultProxyConnectorAdmin;
  26 import org.apache.archiva.admin.repository.remote.DefaultRemoteRepositoryAdmin;
  27 import org.apache.archiva.configuration.ArchivaConfiguration;
  28 import org.apache.archiva.configuration.Configuration;
  29 import org.apache.archiva.configuration.IndeterminateConfigurationException;
  30 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  31 import org.apache.archiva.configuration.ProxyConnectorConfiguration;
  32 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  33 import org.apache.archiva.policies.CachedFailuresPolicy;
  34 import org.apache.archiva.policies.ChecksumPolicy;
  35 import org.apache.archiva.policies.PropagateErrorsDownloadPolicy;
  36 import org.apache.archiva.policies.PropagateErrorsOnUpdateDownloadPolicy;
  37 import org.apache.archiva.policies.ReleasesPolicy;
  38 import org.apache.archiva.policies.SnapshotsPolicy;
  39 import org.apache.archiva.web.action.AbstractWebworkTestCase;
  40 import org.apache.archiva.redback.components.registry.RegistryException;
  41 import org.apache.archiva.redback.integration.interceptor.SecureActionBundle;
  42 import org.easymock.MockControl;
  43
  44 import java.util.List;
  45 import java.util.Map;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48
  49 /**
  50  * EditProxyConnectorActionTest
  51  *
  52  *
  53  */
  54 public class EditProxyConnectorActionTest
  55     extends AbstractWebworkTestCase
  56 {
  57     private static final String TEST_TARGET_ID = "central";
  58
  59     private static final String TEST_SOURCE_ID = "corporate";
  60
  61     private EditProxyConnectorAction action;
  62
  63     private MockControl archivaConfigurationControl;
  64
  65     private ArchivaConfiguration archivaConfiguration;
  66
  67     @Override
  68     @Before
  69     public void setUp()
  70         throws Exception
  71     {
  72         super.setUp();
  73
  74         action = (EditProxyConnectorAction) getActionProxy( "/admin/editProxyConnector.action" ).getAction();
  75
  76         archivaConfigurationControl = MockControl.createControl( ArchivaConfiguration.class );
  77         archivaConfiguration = (ArchivaConfiguration) archivaConfigurationControl.getMock();
  78
  79
  80
  81         ( (DefaultManagedRepositoryAdmin) action.getManagedRepositoryAdmin() ).setArchivaConfiguration(
  82             archivaConfiguration );
  83         ( (DefaultRemoteRepositoryAdmin) action.getRemoteRepositoryAdmin() ).setArchivaConfiguration(
  84             archivaConfiguration );
  85         ( (DefaultProxyConnectorAdmin) action.getProxyConnectorAdmin() ).setArchivaConfiguration(
  86             archivaConfiguration );
  87     }
  88
  89     private void expectConfigurationRequests( int requestConfigCount )
  90         throws org.apache.archiva.redback.components.registry.RegistryException, IndeterminateConfigurationException
  91     {
  92         expectConfigurationRequests( requestConfigCount, 1 );
  93     }
  94
  95     private void expectConfigurationRequests( int requestConfigCount, int saveRequestCount )
  96         throws RegistryException, IndeterminateConfigurationException
  97     {
  98         Configuration config = createInitialConfiguration();
  99
 100         archivaConfigurationControl.expectAndReturn( archivaConfiguration.getConfiguration(), config,
 101                                                      requestConfigCount , 20);
 102         //archivaConfiguration.getConfiguration();
 103         //archivaConfigurationControl.setReturnValue( config, requestConfigCount );
 104
 105         for ( int i = 0; i <= saveRequestCount; i++ )
 106         {
 107             archivaConfiguration.save( config );
 108         }
 109
 110         ( (DefaultManagedRepositoryAdmin) action.getManagedRepositoryAdmin() ).setArchivaConfiguration(
 111             archivaConfiguration );
 112         ( (DefaultRemoteRepositoryAdmin) action.getRemoteRepositoryAdmin() ).setArchivaConfiguration(
 113             archivaConfiguration );
 114         ( (DefaultProxyConnectorAdmin) action.getProxyConnectorAdmin() ).setArchivaConfiguration(
 115             archivaConfiguration );
 116     }
 117
 118     @Test
 119     public void testAddBlackListPattern()
 120         throws Exception
 121     {
 122         expectConfigurationRequests( 7 );
 123         archivaConfigurationControl.replay();
 124
 125         // Prepare Test.
 126         action.setSource( TEST_SOURCE_ID );
 127         action.setTarget( TEST_TARGET_ID );
 128         action.prepare();
 129         ProxyConnector connector = action.getConnector();
 130         assertInitialProxyConnector( connector );
 131
 132         // Perform Test w/no values.
 133         preRequest( action );
 134         String status = action.addBlackListPattern();
 135         assertEquals( Action.INPUT, status );
 136
 137         // Should have returned an error, with no blacklist pattern added.
 138         assertHasErrors( action );
 139         assertEquals( 0, connector.getBlackListPatterns().size() );
 140
 141         // Try again, but now with a pattern to add.
 142         action.setBlackListPattern( "**/*-javadoc.jar" );
 143         preRequest( action );
 144         status = action.addBlackListPattern();
 145         assertEquals( Action.INPUT, status );
 146
 147         // Should have no error, and 1 blacklist pattern added.
 148         assertNoErrors( action );
 149         assertEquals( 1, connector.getBlackListPatterns().size() );
 150     }
 151
 152     @Test
 153     public void testAddProperty()
 154         throws Exception
 155     {
 156         expectConfigurationRequests( 7 );
 157         archivaConfigurationControl.replay();
 158
 159         // Prepare Test.
 160         action.setSource( TEST_SOURCE_ID );
 161         action.setTarget( TEST_TARGET_ID );
 162         action.prepare();
 163         ProxyConnector connector = action.getConnector();
 164         assertInitialProxyConnector( connector );
 165
 166         // Perform Test w/no values.
 167         preRequest( action );
 168         String status = action.addProperty();
 169         assertEquals( Action.INPUT, status );
 170
 171         // Should have returned an error, with no property pattern added.
 172         assertHasErrors( action );
 173         assertEquals( 0, connector.getProperties().size() );
 174
 175         // Try again, but now with a property key/value to add.
 176         action.setPropertyKey( "eat-a" );
 177         action.setPropertyValue( "gramov-a-bits" );
 178         preRequest( action );
 179         status = action.addProperty();
 180         assertEquals( Action.INPUT, status );
 181
 182         // Should have no error, and 1 property added.
 183         assertNoErrors( action );
 184         assertEquals( 1, connector.getProperties().size() );
 185         assertEquals( "gramov-a-bits", connector.getProperties().get( "eat-a" ) );
 186     }
 187
 188     @Test
 189     public void testAddWhiteListPattern()
 190         throws Exception
 191     {
 192         expectConfigurationRequests( 7 );
 193         archivaConfigurationControl.replay();
 194
 195         // Prepare Test.
 196         action.setSource( TEST_SOURCE_ID );
 197         action.setTarget( TEST_TARGET_ID );
 198         action.prepare();
 199         ProxyConnector connector = action.getConnector();
 200         assertInitialProxyConnector( connector );
 201
 202         // Perform Test w/no values.
 203         preRequest( action );
 204         String status = action.addWhiteListPattern();
 205         assertEquals( Action.INPUT, status );
 206
 207         // Should have returned an error, with no whitelist pattern added.
 208         assertHasErrors( action );
 209         assertEquals( 0, connector.getWhiteListPatterns().size() );
 210
 211         // Try again, but now with a pattern to add.
 212         action.setWhiteListPattern( "**/*.jar" );
 213         preRequest( action );
 214         status = action.addWhiteListPattern();
 215         assertEquals( Action.INPUT, status );
 216
 217         // Should have no error, and 1 whitelist pattern added.
 218         assertNoErrors( action );
 219         assertEquals( 1, connector.getWhiteListPatterns().size() );
 220     }
 221
 222     @SuppressWarnings( "unchecked" )
 223     @Test
 224     public void testEditProxyConnectorCommit()
 225         throws Exception
 226     {
 227         expectConfigurationRequests( 9, 2 );
 228         archivaConfigurationControl.replay();
 229
 230         // Prepare Test.
 231         action.setSource( TEST_SOURCE_ID );
 232         action.setTarget( TEST_TARGET_ID );
 233         action.prepare();
 234         ProxyConnector connector = action.getConnector();
 235         assertInitialProxyConnector( connector );
 236         // forms will use an array
 237         //connector.getProperties().put( "eat-a", new String[]{ "gramov-a-bits" } );
 238         // FIXME check the array mode
 239         connector.getProperties().put( "eat-a", "gramov-a-bits" );
 240
 241         // Create the input screen.
 242         assertRequestStatus( action, Action.SUCCESS, "commit" );
 243         assertNoErrors( action );
 244
 245         // Test configuration.
 246         List<ProxyConnectorConfiguration> proxyConfigs = archivaConfiguration.getConfiguration().getProxyConnectors();
 247         assertNotNull( proxyConfigs );
 248         assertEquals( 1, proxyConfigs.size() );
 249
 250         ProxyConnectorConfiguration actualConnector = proxyConfigs.get( 0 );
 251
 252         assertNotNull( actualConnector );
 253         // The use of "(direct connection)" should result in a proxyId which is <null>.
 254         assertNull( actualConnector.getProxyId() );
 255         assertEquals( "corporate", actualConnector.getSourceRepoId() );
 256         assertEquals( "central", actualConnector.getTargetRepoId() );
 257
 258     }
 259
 260     @Test
 261     public void testEditProxyConnectorInitialPage()
 262         throws Exception
 263     {
 264         expectConfigurationRequests( 3 );
 265         archivaConfigurationControl.replay();
 266
 267         action.setSource( TEST_SOURCE_ID );
 268         action.setTarget( TEST_TARGET_ID );
 269         action.prepare();
 270         ProxyConnector connector = action.getConnector();
 271         assertInitialProxyConnector( connector );
 272
 273         String status = action.input();
 274         assertEquals( Action.INPUT, status );
 275     }
 276
 277     @Test
 278     public void testRemoveBlackListPattern()
 279         throws Exception
 280     {
 281         expectConfigurationRequests( 7 );
 282         archivaConfigurationControl.replay();
 283
 284         // Prepare Test.
 285         action.setSource( TEST_SOURCE_ID );
 286         action.setTarget( TEST_TARGET_ID );
 287         action.prepare();
 288         ProxyConnector connector = action.getConnector();
 289         assertInitialProxyConnector( connector );
 290
 291         // Add some arbitrary blacklist patterns.
 292         connector.addBlackListPattern( "**/*-javadoc.jar" );
 293         connector.addBlackListPattern( "**/*.war" );
 294
 295         // Perform Test w/no pattern value.
 296         preRequest( action );
 297         String status = action.removeBlackListPattern();
 298         assertEquals( Action.INPUT, status );
 299
 300         // Should have returned an error, with no blacklist pattern removed.
 301         assertHasErrors( action );
 302         assertEquals( 2, connector.getBlackListPatterns().size() );
 303
 304         // Perform test w/invalid (non-existant) pattern value to remove.
 305         preRequest( action );
 306         action.setPattern( "**/*oops*" );
 307         status = action.removeBlackListPattern();
 308         assertEquals( Action.INPUT, status );
 309
 310         // Should have returned an error, with no blacklist pattern removed.
 311         assertHasErrors( action );
 312         assertEquals( 2, connector.getBlackListPatterns().size() );
 313
 314         // Try again, but now with a valid pattern to remove.
 315         action.setPattern( "**/*-javadoc.jar" );
 316         preRequest( action );
 317         status = action.removeBlackListPattern();
 318         assertEquals( Action.INPUT, status );
 319
 320         // Should have no error, and 1 blacklist pattern left.
 321         assertNoErrors( action );
 322         assertEquals( 1, connector.getBlackListPatterns().size() );
 323         assertEquals( "Should have left 1 blacklist pattern", "**/*.war", connector.getBlackListPatterns().get( 0 ) );
 324     }
 325
 326     @Test
 327     public void testRemoveProperty()
 328         throws Exception
 329     {
 330         expectConfigurationRequests( 7 );
 331         archivaConfigurationControl.replay();
 332
 333         // Prepare Test.
 334         action.setSource( TEST_SOURCE_ID );
 335         action.setTarget( TEST_TARGET_ID );
 336         action.prepare();
 337         ProxyConnector connector = action.getConnector();
 338         assertInitialProxyConnector( connector );
 339
 340         // Add some arbitrary properties.
 341         connector.addProperty( "username", "general-tso" );
 342         connector.addProperty( "password", "chicken" );
 343
 344         // Perform Test w/no property key.
 345         preRequest( action );
 346         String status = action.removeProperty();
 347         assertEquals( Action.INPUT, status );
 348
 349         // Should have returned an error, with no properties removed.
 350         assertHasErrors( action );
 351         assertEquals( 2, connector.getProperties().size() );
 352
 353         // Perform test w/invalid (non-existant) property key to remove.
 354         preRequest( action );
 355         action.setPropertyKey( "slurm" );
 356         status = action.removeProperty();
 357         assertEquals( Action.INPUT, status );
 358
 359         // Should have returned an error, with no properties removed.
 360         assertHasErrors( action );
 361         assertEquals( 2, connector.getProperties().size() );
 362
 363         // Try again, but now with a valid property to remove.
 364         preRequest( action );
 365         action.setPropertyKey( "password" );
 366         status = action.removeProperty();
 367         assertEquals( Action.INPUT, status );
 368
 369         // Should have no error, and 1 property left.
 370         assertNoErrors( action );
 371         assertEquals( 1, connector.getProperties().size() );
 372         assertEquals( "Should have left 1 property", "general-tso", connector.getProperties().get( "username" ) );
 373     }
 374
 375     @Test
 376     public void testRemoveWhiteListPattern()
 377         throws Exception
 378     {
 379         expectConfigurationRequests( 7 );
 380         archivaConfigurationControl.replay();
 381
 382         // Prepare Test.
 383         action.setSource( TEST_SOURCE_ID );
 384         action.setTarget( TEST_TARGET_ID );
 385         action.prepare();
 386         ProxyConnector connector = action.getConnector();
 387         assertInitialProxyConnector( connector );
 388
 389         // Add some arbitrary whitelist patterns.
 390         connector.addWhiteListPattern( "javax/**/*" );
 391         connector.addWhiteListPattern( "com/sun/**/*" );
 392
 393         // Perform Test w/no pattern value.
 394         preRequest( action );
 395         String status = action.removeWhiteListPattern();
 396         assertEquals( Action.INPUT, status );
 397
 398         // Should have returned an error, with no whitelist pattern removed.
 399         assertHasErrors( action );
 400         assertEquals( 2, connector.getWhiteListPatterns().size() );
 401
 402         // Perform test w/invalid (non-existant) pattern value to remove.
 403         preRequest( action );
 404         action.setPattern( "**/*oops*" );
 405         status = action.removeWhiteListPattern();
 406         assertEquals( Action.INPUT, status );
 407
 408         // Should have returned an error, with no whitelist pattern removed.
 409         assertHasErrors( action );
 410         assertEquals( 2, connector.getWhiteListPatterns().size() );
 411
 412         // Try again, but now with a valid pattern to remove.
 413         action.setPattern( "com/sun/**/*" );
 414         preRequest( action );
 415         status = action.removeWhiteListPattern();
 416         assertEquals( Action.INPUT, status );
 417
 418         // Should have no error, and 1 whitelist pattern left.
 419         assertNoErrors( action );
 420         assertEquals( 1, connector.getWhiteListPatterns().size() );
 421         assertEquals( "Should have left 1 whitelist pattern", "javax/**/*", connector.getWhiteListPatterns().get( 0 ) );
 422     }
 423
 424     @Test
 425     public void testSecureActionBundle()
 426         throws Exception
 427     {
 428         /* Configuration will be requested at least 3 times. */
 429         archivaConfiguration.getConfiguration();
 430         archivaConfigurationControl.setReturnValue( new Configuration(), 3 );
 431         archivaConfigurationControl.replay();
 432
 433         action.prepare();
 434         SecureActionBundle bundle = action.getSecureActionBundle();
 435         assertTrue( bundle.requiresAuthentication() );
 436         assertEquals( 1, bundle.getAuthorizationTuples().size() );
 437     }
 438
 439     private void assertInitialProxyConnector( ProxyConnector connector )
 440     {
 441         assertNotNull( connector );
 442         assertNotNull( connector.getBlackListPatterns() );
 443         assertNotNull( connector.getWhiteListPatterns() );
 444         assertNotNull( connector.getProperties() );
 445
 446         assertEquals( TEST_SOURCE_ID, connector.getSourceRepoId() );
 447         assertEquals( TEST_TARGET_ID, connector.getTargetRepoId() );
 448     }
 449
 450     @SuppressWarnings( "unchecked" )
 451     private Configuration createInitialConfiguration()
 452     {
 453         Configuration config = new Configuration();
 454
 455         ManagedRepositoryConfiguration managedRepo = new ManagedRepositoryConfiguration();
 456         managedRepo.setId( TEST_SOURCE_ID );
 457         managedRepo.setLayout( "${java.io.tmpdir}/archiva-test/managed-repo" );
 458         managedRepo.setReleases( true );
 459
 460         config.addManagedRepository( managedRepo );
 461
 462         RemoteRepositoryConfiguration remoteRepo = new RemoteRepositoryConfiguration();
 463         remoteRepo.setId( TEST_TARGET_ID );
 464         remoteRepo.setUrl( "http://repo1.maven.org/maven2/" );
 465
 466         config.addRemoteRepository( remoteRepo );
 467
 468         ProxyConnectorConfiguration connector = new ProxyConnectorConfiguration();
 469         connector.setSourceRepoId( TEST_SOURCE_ID );
 470         connector.setTargetRepoId( TEST_TARGET_ID );
 471
 472         // TODO: Set these options programatically via list of available policies.
 473         Map<String, String> policies = connector.getPolicies();
 474         policies.put( "releases", new ReleasesPolicy().getDefaultOption() );
 475         policies.put( "snapshots", new SnapshotsPolicy().getDefaultOption() );
 476         policies.put( "checksum", new ChecksumPolicy().getDefaultOption() );
 477         policies.put( "cache-failures", new CachedFailuresPolicy().getDefaultOption() );
 478         policies.put( "propagate-errors", new PropagateErrorsDownloadPolicy().getDefaultOption() );
 479         policies.put( "propagate-errors-on-update", new PropagateErrorsOnUpdateDownloadPolicy().getDefaultOption() );
 480
 481         config.addProxyConnector( connector );
 482
 483         return config;
 484     }
 485 }