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

   1 package org.apache.archiva.admin.repository.managed;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.apache.archiva.admin.repository.AbstractRepositoryAdminTest;
  22 import org.apache.archiva.audit.AuditEvent;
  23 import org.apache.archiva.security.common.ArchivaRoleConstants;
  24 import org.apache.commons.io.FileUtils;
  25 import org.apache.commons.lang.StringUtils;
  26 import org.junit.Test;
  27
  28 import java.io.File;
  29 import java.util.List;
  30
  31 /**
  32  * @author Olivier Lamy
  33  */
  34 public class ManagedRepositoryAdminTest
  35     extends AbstractRepositoryAdminTest
  36 {
  37     public static final String STAGE_REPO_ID_END = DefaultManagedRepositoryAdmin.STAGE_REPO_ID_END;
  38
  39     @Test
  40     public void getAllManagedRepos()
  41         throws Exception
  42     {
  43         mockAuditListener.clearEvents();
  44         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
  45         assertNotNull( repos );
  46         assertTrue( repos.size() > 0 );
  47         log.info( "repos " + repos );
  48
  49         // check default internal
  50         ManagedRepository internal = findManagedRepoById( repos, "internal" );
  51         assertNotNull( internal );
  52         assertTrue( internal.isReleases() );
  53         assertFalse( internal.isSnapshots() );
  54         mockAuditListener.clearEvents();
  55     }
  56
  57     @Test
  58     public void getById()
  59         throws Exception
  60     {
  61         mockAuditListener.clearEvents();
  62         ManagedRepository repo = managedRepositoryAdmin.getManagedRepository( "internal" );
  63         assertNotNull( repo );
  64         mockAuditListener.clearEvents();
  65     }
  66
  67     @Test
  68     public void addDeleteManagedRepo()
  69         throws Exception
  70     {
  71         mockAuditListener.clearEvents();
  72
  73         String repoId = "test-new-one";
  74
  75         String repoLocation = APPSERVER_BASE_PATH + File.separator + repoId;
  76
  77         File repoDir = clearRepoLocation( repoLocation );
  78
  79         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
  80         assertNotNull( repos );
  81         int initialSize = repos.size();
  82         assertTrue( initialSize > 0 );
  83
  84         ManagedRepository repo = new ManagedRepository();
  85         repo.setId( repoId );
  86         repo.setName( "test repo" );
  87         repo.setLocation( repoLocation );
  88         repo.setCronExpression( "0 0 * * * ?" );
  89         managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() );
  90         repos = managedRepositoryAdmin.getManagedRepositories();
  91         assertNotNull( repos );
  92         assertEquals( initialSize + 1, repos.size() );
  93
  94         assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId ) );
  95
  96         assertTemplateRoleExists( repoId );
  97
  98         managedRepositoryAdmin.deleteManagedRepository( repoId, getFakeAuditInformation(), false );
  99
 100         // deleteContents false
 101         assertTrue( repoDir.exists() );
 102
 103         repos = managedRepositoryAdmin.getManagedRepositories();
 104         assertNotNull( repos );
 105         assertEquals( initialSize, repos.size() );
 106
 107         assertTemplateRoleNotExists( repoId );
 108
 109         assertEquals( 2, mockAuditListener.getAuditEvents().size() );
 110
 111         assertAuditListenerCallAddAndDelete();
 112
 113         mockAuditListener.clearEvents();
 114     }
 115
 116     @Test
 117     public void updateDeleteManagedRepo()
 118         throws Exception
 119     {
 120         String repoId = "test-new-one";
 121
 122         String repoLocation = APPSERVER_BASE_PATH + File.separator + "new-path";
 123
 124         File repoDir = clearRepoLocation( repoLocation );
 125
 126         mockAuditListener.clearEvents();
 127         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
 128         assertNotNull( repos );
 129         int initialSize = repos.size();
 130         assertTrue( initialSize > 0 );
 131
 132         ManagedRepository repo = new ManagedRepository();
 133         repo.setId( repoId );
 134         repo.setName( "test repo" );
 135         repo.setLocation( repoLocation );
 136         repo.setCronExpression( "0 0 * * * ?" );
 137         managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() );
 138
 139         assertTemplateRoleExists( repoId );
 140
 141         repos = managedRepositoryAdmin.getManagedRepositories();
 142         assertNotNull( repos );
 143         assertEquals( initialSize + 1, repos.size() );
 144
 145         String newName = "test repo update";
 146
 147         repo.setName( newName );
 148
 149         repo.setLocation( repoLocation );
 150         repo.setCronExpression( "0 0 * * * ?" );
 151
 152         managedRepositoryAdmin.updateManagedRepository( repo, false, getFakeAuditInformation(), false );
 153
 154         repo = managedRepositoryAdmin.getManagedRepository( repoId );
 155         assertNotNull( repo );
 156         assertEquals( newName, repo.getName() );
 157         assertEquals( new File( repoLocation ).getCanonicalPath(), new File( repo.getLocation() ).getCanonicalPath() );
 158         assertTrue( new File( repoLocation ).exists() );
 159
 160         assertTemplateRoleExists( repoId );
 161
 162         managedRepositoryAdmin.deleteManagedRepository( repo.getId(), getFakeAuditInformation(), false );
 163
 164         // check deleteContents false
 165         assertTrue( repoDir.exists() );
 166
 167         assertTemplateRoleNotExists( repoId );
 168
 169         assertAuditListenerCallAndUpdateAddAndDelete( false );
 170
 171         mockAuditListener.clearEvents();
 172
 173     }
 174
 175
 176     @Test
 177     public void addDeleteManagedRepoWithStaged()
 178         throws Exception
 179     {
 180
 181         String repoId = "test-new-one";
 182         String repoLocation = APPSERVER_BASE_PATH + File.separator + repoId;
 183
 184         File repoDir = clearRepoLocation( repoLocation );
 185
 186         mockAuditListener.clearEvents();
 187         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
 188         assertNotNull( repos );
 189         int initialSize = repos.size();
 190         assertTrue( initialSize > 0 );
 191
 192         ManagedRepository repo = new ManagedRepository();
 193         repo.setId( repoId );
 194         repo.setName( "test repo" );
 195         repo.setLocation( repoLocation );
 196         repo.setCronExpression( "0 0 * * * ?" );
 197         managedRepositoryAdmin.addManagedRepository( repo, true, getFakeAuditInformation() );
 198         repos = managedRepositoryAdmin.getManagedRepositories();
 199         assertNotNull( repos );
 200         assertEquals( initialSize + 2, repos.size() );
 201
 202         assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId ) );
 203
 204         assertTemplateRoleExists( repoId );
 205
 206         assertTrue( repoDir.exists() );
 207
 208         assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId + STAGE_REPO_ID_END ) );
 209
 210         assertTemplateRoleExists( repoId + STAGE_REPO_ID_END );
 211
 212         assertTrue( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
 213
 214         managedRepositoryAdmin.deleteManagedRepository( repoId, getFakeAuditInformation(), true );
 215
 216         assertFalse( repoDir.exists() );
 217
 218         assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
 219
 220         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 221
 222         repos = managedRepositoryAdmin.getManagedRepositories();
 223         assertNotNull( repos );
 224         assertEquals( initialSize, repos.size() );
 225
 226         assertTemplateRoleNotExists( repoId );
 227
 228         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 229
 230         mockAuditListener.clearEvents();
 231
 232     }
 233
 234     @Test
 235     public void updateDeleteManagedRepoWithStagedRepo()
 236         throws Exception
 237     {
 238         String repoId = "test-new-one";
 239
 240         String repoLocation = APPSERVER_BASE_PATH + File.separator + "new-path";
 241
 242         String stageRepoLocation = APPSERVER_BASE_PATH + File.separator + repoId;
 243
 244         File repoDir = clearRepoLocation( repoLocation );
 245
 246         mockAuditListener.clearEvents();
 247         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
 248         assertNotNull( repos );
 249         int initialSize = repos.size();
 250         assertTrue( initialSize > 0 );
 251
 252         ManagedRepository repo = getTestManagedRepository( repoId, repoLocation );
 253
 254         managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() );
 255
 256         assertTemplateRoleExists( repoId );
 257
 258         assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
 259
 260         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 261
 262         repos = managedRepositoryAdmin.getManagedRepositories();
 263         assertNotNull( repos );
 264         assertEquals( initialSize + 1, repos.size() );
 265
 266         repo = managedRepositoryAdmin.getManagedRepository( repoId );
 267
 268         assertEquals( getTestManagedRepository( repoId, repoLocation ).getIndexDirectory(), repo.getIndexDirectory() );
 269
 270         String newName = "test repo update";
 271
 272         repo.setName( newName );
 273
 274         repo.setLocation( repoLocation );
 275
 276         managedRepositoryAdmin.updateManagedRepository( repo, true, getFakeAuditInformation(), false );
 277
 278         repo = managedRepositoryAdmin.getManagedRepository( repoId );
 279         assertNotNull( repo );
 280         assertEquals( newName, repo.getName() );
 281         assertEquals( new File( repoLocation ).getCanonicalPath(), new File( repo.getLocation() ).getCanonicalPath() );
 282         assertTrue( new File( repoLocation ).exists() );
 283         assertEquals( getTestManagedRepository( repoId, repoLocation ).getCronExpression(), repo.getCronExpression() );
 284         assertEquals( getTestManagedRepository( repoId, repoLocation ).getLayout(), repo.getLayout() );
 285         assertEquals( getTestManagedRepository( repoId, repoLocation ).getId(), repo.getId() );
 286         assertEquals( getTestManagedRepository( repoId, repoLocation ).getIndexDirectory(), repo.getIndexDirectory() );
 287
 288         assertEquals( getTestManagedRepository( repoId, repoLocation ).getDaysOlder(), repo.getDaysOlder() );
 289         assertEquals( getTestManagedRepository( repoId, repoLocation ).getRetentionCount(), repo.getRetentionCount() );
 290         assertEquals( getTestManagedRepository( repoId, repoLocation ).isDeleteReleasedSnapshots(),
 291                       repo.isDeleteReleasedSnapshots() );
 292
 293         assertTemplateRoleExists( repoId );
 294
 295         assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() );
 296
 297         assertTemplateRoleExists( repoId + STAGE_REPO_ID_END );
 298
 299         managedRepositoryAdmin.deleteManagedRepository( repo.getId(), getFakeAuditInformation(), false );
 300
 301         // check deleteContents false
 302         assertTrue( repoDir.exists() );
 303
 304         assertTemplateRoleNotExists( repoId );
 305
 306         assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() );
 307
 308         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 309
 310         assertAuditListenerCallAndUpdateAddAndDelete( true );
 311
 312         mockAuditListener.clearEvents();
 313
 314     }
 315
 316     //----------------------------------
 317     // utility methods
 318     //----------------------------------
 319
 320     private void assertTemplateRoleExists( String repoId )
 321         throws Exception
 322     {
 323         assertTrue( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) );
 324         assertTrue( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) );
 325     }
 326
 327
 328     private void assertTemplateRoleNotExists( String repoId )
 329         throws Exception
 330     {
 331         assertFalse( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) );
 332         assertFalse( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) );
 333     }
 334
 335     private void assertAuditListenerCallAddAndDelete()
 336     {
 337         assertEquals( 2, mockAuditListener.getAuditEvents().size() );
 338
 339         assertEquals( AuditEvent.ADD_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 0 ).getAction() );
 340         assertEquals( "root", mockAuditListener.getAuditEvents().get( 0 ).getUserId() );
 341         assertEquals( "archiva-localhost", mockAuditListener.getAuditEvents().get( 0 ).getRemoteIP() );
 342
 343         assertEquals( AuditEvent.DELETE_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 344         assertEquals( "root", mockAuditListener.getAuditEvents().get( 0 ).getUserId() );
 345     }
 346
 347     private void assertAuditListenerCallAndUpdateAddAndDelete( boolean stageNeeded )
 348     {
 349         if ( stageNeeded )
 350         {
 351             assertEquals( "not 4 audit events " + mockAuditListener.getAuditEvents(), 4,
 352                           mockAuditListener.getAuditEvents().size() );
 353         }
 354         else
 355         {
 356             assertEquals( "not 3 audit events " + mockAuditListener.getAuditEvents(), 3,
 357                           mockAuditListener.getAuditEvents().size() );
 358         }
 359         assertEquals( AuditEvent.ADD_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 0 ).getAction() );
 360         assertEquals( "root", mockAuditListener.getAuditEvents().get( 0 ).getUserId() );
 361         assertEquals( "archiva-localhost", mockAuditListener.getAuditEvents().get( 0 ).getRemoteIP() );
 362
 363         if ( stageNeeded )
 364         {
 365             assertEquals( AuditEvent.ADD_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 366             assertEquals( AuditEvent.MODIFY_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 2 ).getAction() );
 367             assertEquals( AuditEvent.DELETE_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 3 ).getAction() );
 368         }
 369         else
 370         {
 371             assertEquals( AuditEvent.MODIFY_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 372             assertEquals( AuditEvent.DELETE_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 2 ).getAction() );
 373         }
 374
 375     }
 376
 377
 378
 379 }