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.xwork.Action;
  23 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  24 import org.apache.maven.archiva.configuration.Configuration;
  25 import org.apache.maven.archiva.configuration.IndeterminateConfigurationException;
  26 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  27 import org.apache.maven.archiva.configuration.ProxyConnectorConfiguration;
  28 import org.apache.maven.archiva.configuration.RemoteRepositoryConfiguration;
  29 import org.apache.maven.archiva.configuration.RepositoryGroupConfiguration;
  30 import org.apache.maven.archiva.model.ArchivaProjectModel;
  31 import org.apache.maven.archiva.security.ArchivaRoleConstants;
  32 import org.codehaus.plexus.redback.role.RoleManager;
  33 import org.codehaus.plexus.redback.role.RoleManagerException;
  34 import org.codehaus.plexus.redback.xwork.interceptor.SecureActionBundle;
  35 import org.codehaus.plexus.redback.xwork.interceptor.SecureActionException;
  36 import org.codehaus.plexus.registry.RegistryException;
  37 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  38 import org.easymock.MockControl;
  39
  40 import java.io.File;
  41 import java.util.ArrayList;
  42 import java.util.Collections;
  43 import java.util.List;
  44
  45 /**
  46  * DeleteManagedRepositoryActionTest
  47  *
  48  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  49  * @version $Id$
  50  */
  51 public class DeleteManagedRepositoryActionTest
  52     extends PlexusInSpringTestCase
  53 {
  54     private DeleteManagedRepositoryAction action;
  55
  56     private RoleManager roleManager;
  57
  58     private MockControl roleManagerControl;
  59
  60     private MockControl archivaConfigurationControl;
  61
  62     private ArchivaConfiguration archivaConfiguration;
  63
  64     private static final String REPO_ID = "repo-ident";
  65
  66     private File location;
  67
  68     @Override
  69     protected String getPlexusConfigLocation()
  70     {
  71         return AbstractManagedRepositoriesAction.class.getName().replace( '.', '/' ) + "Test.xml";
  72     }
  73
  74     protected void setUp()
  75         throws Exception
  76     {
  77         super.setUp();
  78
  79         action = (DeleteManagedRepositoryAction) lookup( Action.class.getName(), "deleteManagedRepositoryAction" );
  80
  81         archivaConfigurationControl = MockControl.createControl( ArchivaConfiguration.class );
  82         archivaConfiguration = (ArchivaConfiguration) archivaConfigurationControl.getMock();
  83         action.setArchivaConfiguration( archivaConfiguration );
  84
  85         roleManagerControl = MockControl.createControl( RoleManager.class );
  86         roleManager = (RoleManager) roleManagerControl.getMock();
  87         action.setRoleManager( roleManager );
  88         location = getTestFile( "target/test/location" );
  89     }
  90
  91     public void testSecureActionBundle()
  92         throws SecureActionException
  93     {
  94         archivaConfiguration.getConfiguration();
  95         archivaConfigurationControl.setReturnValue( new Configuration() );
  96         archivaConfigurationControl.replay();
  97
  98         action.prepare();
  99         SecureActionBundle bundle = action.getSecureActionBundle();
 100         assertTrue( bundle.requiresAuthentication() );
 101         assertEquals( 1, bundle.getAuthorizationTuples().size() );
 102     }
 103
 104     public void testDeleteRepositoryConfirmation()
 105         throws Exception
 106     {
 107         ManagedRepositoryConfiguration originalRepository = createRepository();
 108         Configuration configuration = createConfigurationForEditing( originalRepository );
 109
 110         archivaConfiguration.getConfiguration();
 111         archivaConfigurationControl.setReturnValue( configuration );
 112         archivaConfigurationControl.replay();
 113
 114         action.setRepoid( REPO_ID );
 115
 116         action.prepare();
 117         assertEquals( REPO_ID, action.getRepoid() );
 118         ManagedRepositoryConfiguration repository = action.getRepository();
 119         assertNotNull( repository );
 120         assertRepositoryEquals( repository, createRepository() );
 121
 122         String status = action.execute();
 123         assertEquals( Action.SUCCESS, status );
 124         repository = action.getRepository();
 125         assertRepositoryEquals( repository, createRepository() );
 126         assertEquals( Collections.singletonList( originalRepository ), configuration.getManagedRepositories() );
 127     }
 128
 129     public void testDeleteRepositoryKeepContent()
 130         throws Exception
 131     {
 132         prepareRoleManagerMock();
 133
 134         Configuration configuration = prepDeletionTest( createRepository(), 4 );
 135
 136         String status = action.deleteEntry();
 137
 138         assertEquals( Action.SUCCESS, status );
 139
 140         assertTrue( configuration.getManagedRepositories().isEmpty() );
 141
 142         assertTrue( location.exists() );
 143     }
 144
 145     public void testDeleteRepositoryDeleteContent()
 146         throws Exception
 147     {
 148         prepareRoleManagerMock();
 149
 150         Configuration configuration = prepDeletionTest( createRepository(), 4 );
 151
 152         String status = action.deleteContents();
 153
 154         assertEquals( Action.SUCCESS, status );
 155
 156         assertTrue( configuration.getManagedRepositories().isEmpty() );
 157
 158         assertFalse( location.exists() );
 159     }
 160
 161     public void testDeleteRepositoryAndAssociatedProxyConnectors()
 162         throws Exception
 163     {
 164         Configuration configuration = prepDeletionTest( createRepository(), 5 );
 165         configuration.addRemoteRepository( createRemoteRepository( "codehaus", "http://repository.codehaus.org" ) );
 166         configuration.addRemoteRepository( createRemoteRepository( "java.net", "http://dev.java.net/maven2" ) );
 167         configuration.addProxyConnector( createProxyConnector( REPO_ID, "codehaus" ) );
 168
 169         prepareRoleManagerMock();
 170
 171         assertEquals( 1, configuration.getProxyConnectors().size() );
 172
 173         String status = action.deleteContents();
 174         assertEquals( Action.SUCCESS, status );
 175
 176         assertTrue( configuration.getManagedRepositories().isEmpty() );
 177         assertEquals( 0, configuration.getProxyConnectors().size() );
 178
 179         assertFalse( location.exists() );
 180     }
 181
 182     public void testDeleteRepositoryCancelled()
 183         throws Exception
 184     {
 185         ManagedRepositoryConfiguration originalRepository = createRepository();
 186         Configuration configuration = prepDeletionTest( originalRepository, 3 );
 187         String status = action.execute();
 188         assertEquals( Action.SUCCESS, status );
 189
 190         ManagedRepositoryConfiguration repository = action.getRepository();
 191         assertRepositoryEquals( repository, createRepository() );
 192         assertEquals( Collections.singletonList( originalRepository ), configuration.getManagedRepositories() );
 193
 194         assertTrue( location.exists() );
 195     }
 196
 197     public void testDeleteRepositoryAndReposUnderRepoGroup()
 198         throws Exception
 199     {
 200         Configuration configuration = prepDeletionTest( createRepository(), 5 );
 201         List<String> repoIds = new ArrayList<String>();
 202         repoIds.add( REPO_ID );
 203         configuration.addRepositoryGroup( createRepoGroup( repoIds, "repo.group" ) );
 204
 205         prepareRoleManagerMock();
 206
 207         assertEquals( 1, configuration.getRepositoryGroups().size() );
 208
 209         String status = action.deleteContents();
 210         assertEquals( Action.SUCCESS, status );
 211
 212         assertTrue( configuration.getManagedRepositories().isEmpty() );
 213         assertEquals( 0, ( ( RepositoryGroupConfiguration ) configuration.getRepositoryGroups().get( 0 ) ).getRepositories().size() );
 214
 215         assertFalse( location.exists() );
 216     }
 217
 218     private Configuration prepDeletionTest( ManagedRepositoryConfiguration originalRepository, int expectCountGetConfig )
 219         throws RegistryException, IndeterminateConfigurationException
 220     {
 221         location.mkdirs();
 222
 223         Configuration configuration = createConfigurationForEditing( originalRepository );
 224
 225         archivaConfiguration.getConfiguration();
 226         archivaConfigurationControl.setReturnValue( configuration, expectCountGetConfig );
 227
 228         archivaConfiguration.save( configuration );
 229         archivaConfigurationControl.replay();
 230
 231         action.setRepoid( REPO_ID );
 232
 233         action.prepare();
 234         assertEquals( REPO_ID, action.getRepoid() );
 235         ManagedRepositoryConfiguration repository = action.getRepository();
 236         assertNotNull( repository );
 237         assertRepositoryEquals( repository, createRepository() );
 238
 239         assertTrue( location.exists() );
 240         return configuration;
 241     }
 242
 243     private void assertRepositoryEquals( ManagedRepositoryConfiguration expectedRepository,
 244                                          ManagedRepositoryConfiguration actualRepository )
 245     {
 246         assertEquals( expectedRepository.getDaysOlder(), actualRepository.getDaysOlder() );
 247         assertEquals( expectedRepository.getId(), actualRepository.getId() );
 248         assertEquals( expectedRepository.getIndexDir(), actualRepository.getIndexDir() );
 249         assertEquals( expectedRepository.getLayout(), actualRepository.getLayout() );
 250         assertEquals( expectedRepository.getLocation(), actualRepository.getLocation() );
 251         assertEquals( expectedRepository.getName(), actualRepository.getName() );
 252         assertEquals( expectedRepository.getRefreshCronExpression(), actualRepository.getRefreshCronExpression() );
 253         assertEquals( expectedRepository.getRetentionCount(), actualRepository.getRetentionCount() );
 254         assertEquals( expectedRepository.isDeleteReleasedSnapshots(), actualRepository.isDeleteReleasedSnapshots() );
 255         assertEquals( expectedRepository.isScanned(), actualRepository.isScanned() );
 256         assertEquals( expectedRepository.isReleases(), actualRepository.isReleases() );
 257         assertEquals( expectedRepository.isSnapshots(), actualRepository.isSnapshots() );
 258     }
 259
 260     private Configuration createConfigurationForEditing( ManagedRepositoryConfiguration repositoryConfiguration )
 261     {
 262         Configuration configuration = new Configuration();
 263         configuration.addManagedRepository( repositoryConfiguration );
 264         return configuration;
 265     }
 266
 267     private ManagedRepositoryConfiguration createRepository()
 268     {
 269         ManagedRepositoryConfiguration r = new ManagedRepositoryConfiguration();
 270         r.setId( REPO_ID );
 271         r.setName( "repo name" );
 272         r.setLocation( location.getAbsolutePath() );
 273         r.setLayout( "default" );
 274         r.setRefreshCronExpression( "* 0/5 * * * ?" );
 275         r.setDaysOlder( 0 );
 276         r.setRetentionCount( 0 );
 277         r.setReleases( true );
 278         r.setSnapshots( true );
 279         r.setScanned( false );
 280         r.setDeleteReleasedSnapshots( false );
 281         return r;
 282     }
 283
 284     private RemoteRepositoryConfiguration createRemoteRepository(String id, String url)
 285     {
 286         RemoteRepositoryConfiguration r = new RemoteRepositoryConfiguration();
 287         r.setId( id );
 288         r.setUrl( url );
 289         r.setLayout( "default" );
 290
 291         return r;
 292     }
 293
 294     private ProxyConnectorConfiguration createProxyConnector( String managedRepoId, String remoteRepoId )
 295     {
 296         ProxyConnectorConfiguration connector = new ProxyConnectorConfiguration();
 297         connector.setSourceRepoId( managedRepoId );
 298         connector.setTargetRepoId( remoteRepoId );
 299
 300         return connector;
 301     }
 302
 303     private RepositoryGroupConfiguration createRepoGroup( List<String> repoIds, String repoGroupId )
 304     {
 305         RepositoryGroupConfiguration repoGroup = new RepositoryGroupConfiguration();
 306         repoGroup.setId( repoGroupId );
 307         repoGroup.setRepositories( repoIds );
 308
 309         return repoGroup;
 310     }
 311
 312     private void prepareRoleManagerMock()
 313         throws RoleManagerException
 314     {
 315         roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID );
 316         roleManagerControl.setReturnValue( true );
 317         roleManager.removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID );
 318         roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID );
 319         roleManagerControl.setReturnValue( true );
 320         roleManager.removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID );
 321         roleManagerControl.replay();
 322     }
 323
 324     protected ArchivaProjectModel createProjectModel( String groupId, String artifactId, String version )
 325     {
 326         ArchivaProjectModel projectModel = new ArchivaProjectModel();
 327         projectModel.setGroupId( groupId );
 328         projectModel.setArtifactId( artifactId );
 329         projectModel.setVersion( version );
 330
 331         return projectModel;
 332     }
 333 }