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