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

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