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