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

   1 package org.apache.maven.archiva.web.action.admin.repositories;
   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.audit.AuditEvent;
  24 import org.apache.archiva.audit.AuditListener;
  25 import org.apache.archiva.metadata.repository.MetadataRepository;
  26 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  27 import org.apache.archiva.metadata.repository.stats.RepositoryStatisticsManager;
  28 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  29 import org.apache.maven.archiva.configuration.Configuration;
  30 import org.apache.maven.archiva.configuration.IndeterminateConfigurationException;
  31 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  32 import org.apache.maven.archiva.configuration.ProxyConnectorConfiguration;
  33 import org.apache.maven.archiva.configuration.RemoteRepositoryConfiguration;
  34 import org.apache.maven.archiva.configuration.RepositoryGroupConfiguration;
  35 import org.apache.maven.archiva.security.ArchivaRoleConstants;
  36 import org.apache.maven.archiva.web.action.AuditEventArgumentsMatcher;
  37 import org.codehaus.plexus.redback.role.RoleManager;
  38 import org.codehaus.plexus.redback.role.RoleManagerException;
  39 import org.codehaus.plexus.registry.RegistryException;
  40 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  41 import org.codehaus.redback.integration.interceptor.SecureActionBundle;
  42 import org.codehaus.redback.integration.interceptor.SecureActionException;
  43 import org.easymock.MockControl;
  44
  45 import java.io.File;
  46 import java.util.Arrays;
  47 import java.util.Collections;
  48 import java.util.List;
  49
  50 /**
  51  * DeleteManagedRepositoryActionTest
  52  *
  53  * @version $Id$
  54  */
  55 public class DeleteManagedRepositoryActionTest
  56     extends PlexusInSpringTestCase
  57 {
  58     private DeleteManagedRepositoryAction action;
  59
  60     private RoleManager roleManager;
  61
  62     private MockControl roleManagerControl;
  63
  64     private MockControl archivaConfigurationControl;
  65
  66     private ArchivaConfiguration archivaConfiguration;
  67
  68     private static final String REPO_ID = "repo-ident";
  69
  70     private File location;
  71
  72     private MockControl repositoryStatisticsManagerControl;
  73
  74     private RepositoryStatisticsManager repositoryStatisticsManager;
  75
  76     protected void setUp()
  77         throws Exception
  78     {
  79         super.setUp();
  80
  81         action = new DeleteManagedRepositoryAction();
  82
  83         archivaConfigurationControl = MockControl.createControl( ArchivaConfiguration.class );
  84         archivaConfiguration = (ArchivaConfiguration) archivaConfigurationControl.getMock();
  85         action.setArchivaConfiguration( archivaConfiguration );
  86
  87         roleManagerControl = MockControl.createControl( RoleManager.class );
  88         roleManager = (RoleManager) roleManagerControl.getMock();
  89         action.setRoleManager( roleManager );
  90         location = getTestFile( "target/test/location" );
  91
  92         repositoryStatisticsManagerControl = MockControl.createControl( RepositoryStatisticsManager.class );
  93         repositoryStatisticsManager = (RepositoryStatisticsManager) repositoryStatisticsManagerControl.getMock();
  94         action.setRepositoryStatisticsManager( repositoryStatisticsManager );
  95
  96         MockControl metadataRepositoryControl = MockControl.createControl( MetadataRepository.class );
  97         MetadataRepository metadataRepository = (MetadataRepository) metadataRepositoryControl.getMock();
  98         metadataRepository.removeRepository( REPO_ID );
  99         action.setMetadataRepository( metadataRepository );
 100
 101         metadataRepositoryControl.replay();
 102     }
 103
 104     public void testSecureActionBundle()
 105         throws SecureActionException
 106     {
 107         archivaConfiguration.getConfiguration();
 108         archivaConfigurationControl.setReturnValue( new Configuration() );
 109         archivaConfigurationControl.replay();
 110
 111         action.prepare();
 112         SecureActionBundle bundle = action.getSecureActionBundle();
 113         assertTrue( bundle.requiresAuthentication() );
 114         assertEquals( 1, bundle.getAuthorizationTuples().size() );
 115     }
 116
 117     public void testDeleteRepositoryConfirmation()
 118         throws Exception
 119     {
 120         ManagedRepositoryConfiguration originalRepository = createRepository();
 121         Configuration configuration = createConfigurationForEditing( originalRepository );
 122
 123         archivaConfiguration.getConfiguration();
 124         archivaConfigurationControl.setReturnValue( configuration );
 125
 126         Configuration stageRepoConfiguration = new Configuration();
 127         stageRepoConfiguration.addManagedRepository( createSatingRepository() );
 128         archivaConfigurationControl.setReturnValue( stageRepoConfiguration );
 129
 130         archivaConfigurationControl.replay();
 131
 132         action.setRepoid( REPO_ID );
 133
 134         action.prepare();
 135         assertEquals( REPO_ID, action.getRepoid() );
 136         ManagedRepositoryConfiguration repository = action.getRepository();
 137         assertNotNull( repository );
 138         assertRepositoryEquals( repository, createRepository() );
 139
 140         String status = action.execute();
 141         assertEquals( Action.SUCCESS, status );
 142
 143         repository = action.getRepository();
 144         assertRepositoryEquals( repository, createRepository() );
 145         assertEquals( Collections.singletonList( originalRepository ), configuration.getManagedRepositories() );
 146     }
 147
 148     public void testDeleteRepositoryKeepContent()
 149         throws Exception
 150     {
 151         // even when we keep the content, we don't keep the metadata at this point
 152         repositoryStatisticsManager.deleteStatistics( REPO_ID );
 153         repositoryStatisticsManagerControl.replay();
 154
 155         prepareRoleManagerMock();
 156
 157         Configuration configuration = prepDeletionTest( createRepository(), 4 );
 158
 159         MockControl control = mockAuditListeners();
 160
 161         MockControl metadataRepositoryControl = mockMetadataRepository();
 162
 163         String status = action.deleteEntry();
 164
 165         assertEquals( Action.SUCCESS, status );
 166
 167         assertTrue( configuration.getManagedRepositories().isEmpty() );
 168
 169         assertTrue( location.exists() );
 170
 171         repositoryStatisticsManagerControl.verify();
 172         control.verify();
 173         metadataRepositoryControl.verify();
 174     }
 175
 176     private MockControl mockMetadataRepository()
 177         throws MetadataRepositoryException
 178     {
 179         MockControl metadataRepositoryControl = MockControl.createControl( MetadataRepository.class );
 180         MetadataRepository metadataRepository = (MetadataRepository) metadataRepositoryControl.getMock();
 181         metadataRepository.removeRepository( REPO_ID );
 182         metadataRepositoryControl.replay();
 183         action.setMetadataRepository( metadataRepository );
 184         return metadataRepositoryControl;
 185     }
 186
 187     private MockControl mockAuditListeners()
 188     {
 189         MockControl control = MockControl.createControl( AuditListener.class );
 190         AuditListener listener = (AuditListener) control.getMock();
 191         listener.auditEvent( new AuditEvent( REPO_ID, "guest", null, AuditEvent.DELETE_MANAGED_REPO ) );
 192         control.setMatcher( new AuditEventArgumentsMatcher() );
 193         control.replay();
 194         action.setAuditListeners( Arrays.asList( listener ) );
 195         return control;
 196     }
 197
 198     public void testDeleteRepositoryDeleteContent()
 199         throws Exception
 200     {
 201         repositoryStatisticsManager.deleteStatistics( REPO_ID );
 202         repositoryStatisticsManagerControl.replay();
 203
 204         prepareRoleManagerMock();
 205
 206         Configuration configuration = prepDeletionTest( createRepository(), 4 );
 207
 208         MockControl control = mockAuditListeners();
 209
 210         MockControl metadataRepositoryControl = mockMetadataRepository();
 211
 212         String status = action.deleteContents();
 213
 214         assertEquals( Action.SUCCESS, status );
 215
 216         assertTrue( configuration.getManagedRepositories().isEmpty() );
 217
 218         assertFalse( location.exists() );
 219
 220         repositoryStatisticsManagerControl.verify();
 221         control.verify();
 222         metadataRepositoryControl.verify();
 223     }
 224
 225     public void testDeleteRepositoryAndAssociatedProxyConnectors()
 226         throws Exception
 227     {
 228         repositoryStatisticsManager.deleteStatistics( REPO_ID );
 229         repositoryStatisticsManagerControl.replay();
 230
 231         Configuration configuration = prepDeletionTest( createRepository(), 5 );
 232         configuration.addRemoteRepository( createRemoteRepository( "codehaus", "http://repository.codehaus.org" ) );
 233         configuration.addRemoteRepository( createRemoteRepository( "java.net", "http://dev.java.net/maven2" ) );
 234         configuration.addProxyConnector( createProxyConnector( REPO_ID, "codehaus" ) );
 235
 236         prepareRoleManagerMock();
 237
 238         assertEquals( 1, configuration.getProxyConnectors().size() );
 239
 240         MockControl control = mockAuditListeners();
 241         MockControl metadataRepositoryControl = mockMetadataRepository();
 242         String status = action.deleteContents();
 243
 244         assertEquals( Action.SUCCESS, status );
 245
 246         assertTrue( configuration.getManagedRepositories().isEmpty() );
 247         assertEquals( 0, configuration.getProxyConnectors().size() );
 248
 249         assertFalse( location.exists() );
 250
 251         repositoryStatisticsManagerControl.verify();
 252         control.verify();
 253         metadataRepositoryControl.verify();
 254     }
 255
 256     public void testDeleteRepositoryCancelled()
 257         throws Exception
 258     {
 259         repositoryStatisticsManagerControl.replay();
 260
 261         ManagedRepositoryConfiguration originalRepository = createRepository();
 262         Configuration configuration = prepDeletionTest( originalRepository, 3 );
 263
 264         String status = action.execute();
 265         assertEquals( Action.SUCCESS, status );
 266
 267         ManagedRepositoryConfiguration repository = action.getRepository();
 268         assertRepositoryEquals( repository, createRepository() );
 269         assertEquals( Collections.singletonList( originalRepository ), configuration.getManagedRepositories() );
 270
 271         assertTrue( location.exists() );
 272
 273         repositoryStatisticsManagerControl.verify();
 274     }
 275
 276
 277     private Configuration prepDeletionTest( ManagedRepositoryConfiguration originalRepository,
 278                                             int expectCountGetConfig )
 279         throws RegistryException, IndeterminateConfigurationException
 280     {
 281         location.mkdirs();
 282
 283         Configuration configuration = createConfigurationForEditing( originalRepository );
 284
 285         archivaConfiguration.getConfiguration();
 286         archivaConfigurationControl.setReturnValue( configuration, expectCountGetConfig );
 287
 288         Configuration stageRepoConfiguration = new Configuration();
 289         stageRepoConfiguration.addManagedRepository( createSatingRepository() );
 290         archivaConfigurationControl.setReturnValue( stageRepoConfiguration );
 291
 292         archivaConfiguration.save( configuration );
 293         archivaConfigurationControl.replay();
 294
 295         action.setRepoid( REPO_ID );
 296
 297         action.prepare();
 298         assertEquals( REPO_ID, action.getRepoid() );
 299         ManagedRepositoryConfiguration repository = action.getRepository();
 300         assertNotNull( repository );
 301         assertRepositoryEquals( repository, createRepository() );
 302
 303         assertTrue( location.exists() );
 304         return configuration;
 305     }
 306
 307     private void assertRepositoryEquals( ManagedRepositoryConfiguration expectedRepository,
 308                                          ManagedRepositoryConfiguration actualRepository )
 309     {
 310         assertEquals( expectedRepository.getDaysOlder(), actualRepository.getDaysOlder() );
 311         assertEquals( expectedRepository.getId(), actualRepository.getId() );
 312         assertEquals( expectedRepository.getIndexDir(), actualRepository.getIndexDir() );
 313         assertEquals( expectedRepository.getLayout(), actualRepository.getLayout() );
 314         assertEquals( expectedRepository.getLocation(), actualRepository.getLocation() );
 315         assertEquals( expectedRepository.getName(), actualRepository.getName() );
 316         assertEquals( expectedRepository.getRefreshCronExpression(), actualRepository.getRefreshCronExpression() );
 317         assertEquals( expectedRepository.getRetentionCount(), actualRepository.getRetentionCount() );
 318         assertEquals( expectedRepository.isDeleteReleasedSnapshots(), actualRepository.isDeleteReleasedSnapshots() );
 319         assertEquals( expectedRepository.isScanned(), actualRepository.isScanned() );
 320         assertEquals( expectedRepository.isReleases(), actualRepository.isReleases() );
 321         assertEquals( expectedRepository.isSnapshots(), actualRepository.isSnapshots() );
 322     }
 323
 324     private Configuration createConfigurationForEditing( ManagedRepositoryConfiguration repositoryConfiguration )
 325     {
 326         Configuration configuration = new Configuration();
 327         configuration.addManagedRepository( repositoryConfiguration );
 328         return configuration;
 329     }
 330
 331     private ManagedRepositoryConfiguration createRepository()
 332     {
 333         ManagedRepositoryConfiguration r = new ManagedRepositoryConfiguration();
 334         r.setId( REPO_ID );
 335         r.setName( "repo name" );
 336         r.setLocation( location.getAbsolutePath() );
 337         r.setLayout( "default" );
 338         r.setRefreshCronExpression( "* 0/5 * * * ?" );
 339         r.setDaysOlder( 0 );
 340         r.setRetentionCount( 0 );
 341         r.setReleases( true );
 342         r.setSnapshots( true );
 343         r.setScanned( false );
 344         r.setDeleteReleasedSnapshots( false );
 345         return r;
 346     }
 347
 348     private ManagedRepositoryConfiguration createSatingRepository()
 349     {
 350         ManagedRepositoryConfiguration r = new ManagedRepositoryConfiguration();
 351         r.setId( REPO_ID + "-stage" );
 352         r.setName( "repo name" );
 353         r.setLocation( location.getAbsolutePath() );
 354         r.setLayout( "default" );
 355         r.setRefreshCronExpression( "* 0/5 * * * ?" );
 356         r.setDaysOlder( 0 );
 357         r.setRetentionCount( 0 );
 358         r.setReleases( true );
 359         r.setSnapshots( true );
 360         r.setScanned( false );
 361         r.setDeleteReleasedSnapshots( false );
 362         return r;
 363     }
 364
 365     private RemoteRepositoryConfiguration createRemoteRepository( String id, String url )
 366     {
 367         RemoteRepositoryConfiguration r = new RemoteRepositoryConfiguration();
 368         r.setId( id );
 369         r.setUrl( url );
 370         r.setLayout( "default" );
 371
 372         return r;
 373     }
 374
 375     private ProxyConnectorConfiguration createProxyConnector( String managedRepoId, String remoteRepoId )
 376     {
 377         ProxyConnectorConfiguration connector = new ProxyConnectorConfiguration();
 378         connector.setSourceRepoId( managedRepoId );
 379         connector.setTargetRepoId( remoteRepoId );
 380
 381         return connector;
 382     }
 383
 384     private RepositoryGroupConfiguration createRepoGroup( List<String> repoIds, String repoGroupId )
 385     {
 386         RepositoryGroupConfiguration repoGroup = new RepositoryGroupConfiguration();
 387         repoGroup.setId( repoGroupId );
 388         repoGroup.setRepositories( repoIds );
 389
 390         return repoGroup;
 391     }
 392
 393     private void prepareRoleManagerMock()
 394         throws RoleManagerException
 395     {
 396         roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID );
 397         roleManagerControl.setReturnValue( true );
 398         roleManager.removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID );
 399         roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID );
 400         roleManagerControl.setReturnValue( true );
 401         roleManager.removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID );
 402         roleManagerControl.replay();
 403     }
 404 }