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.codehaus.plexus.redback.role.RoleManager;
  27 import org.junit.Test;
  28
  29 import javax.inject.Inject;
  30 import java.io.File;
  31 import java.util.List;
  32
  33 /**
  34  * @author Olivier Lamy
  35  */
  36 public class ManagedRepositoryAdminTest
  37     extends AbstractRepositoryAdminTest
  38 {
  39
  40     @Inject
  41     private ManagedRepositoryAdmin managedRepositoryAdmin;
  42
  43
  44
  45     @Inject
  46     protected RoleManager roleManager;
  47
  48     public static final String STAGE_REPO_ID_END = DefaultManagedRepositoryAdmin.STAGE_REPO_ID_END;
  49
  50     @Test
  51     public void getAllManagedRepos()
  52         throws Exception
  53     {
  54         mockAuditListener.clearEvents();
  55         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
  56         assertNotNull( repos );
  57         assertTrue( repos.size() > 0 );
  58         log.info( "repos " + repos );
  59
  60         // check default internal
  61         ManagedRepository internal = findManagedRepoById( repos, "internal" );
  62         assertNotNull( internal );
  63         assertTrue( internal.isReleases() );
  64         assertFalse( internal.isSnapshots() );
  65         mockAuditListener.clearEvents();
  66     }
  67
  68     @Test
  69     public void getById()
  70         throws Exception
  71     {
  72         mockAuditListener.clearEvents();
  73         ManagedRepository repo = managedRepositoryAdmin.getManagedRepository( "internal" );
  74         assertNotNull( repo );
  75         mockAuditListener.clearEvents();
  76     }
  77
  78     @Test
  79     public void addDeleteManagedRepo()
  80         throws Exception
  81     {
  82         mockAuditListener.clearEvents();
  83
  84         String repoId = "test-new-one";
  85
  86         String repoLocation = APPSERVER_BASE_PATH + File.separator + repoId;
  87
  88         File repoDir = clearRepoLocation( repoLocation );
  89
  90         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
  91         assertNotNull( repos );
  92         int initialSize = repos.size();
  93         assertTrue( initialSize > 0 );
  94
  95         ManagedRepository repo = new ManagedRepository();
  96         repo.setId( repoId );
  97         repo.setName( "test repo" );
  98         repo.setLocation( repoLocation );
  99         repo.setCronExpression( "0 0 * * * ?" );
 100         managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() );
 101         repos = managedRepositoryAdmin.getManagedRepositories();
 102         assertNotNull( repos );
 103         assertEquals( initialSize + 1, repos.size() );
 104
 105         assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId ) );
 106
 107         assertTemplateRoleExists( repoId );
 108
 109         managedRepositoryAdmin.deleteManagedRepository( repoId, getFakeAuditInformation(), false );
 110
 111         // deleteContents false
 112         assertTrue( repoDir.exists() );
 113
 114         repos = managedRepositoryAdmin.getManagedRepositories();
 115         assertNotNull( repos );
 116         assertEquals( initialSize, repos.size() );
 117
 118         assertTemplateRoleNotExists( repoId );
 119
 120         assertEquals( 2, mockAuditListener.getAuditEvents().size() );
 121
 122         assertAuditListenerCallAddAndDelete();
 123
 124         mockAuditListener.clearEvents();
 125     }
 126
 127     @Test
 128     public void updateDeleteManagedRepo()
 129         throws Exception
 130     {
 131         String repoId = "test-new-one";
 132
 133         String repoLocation = APPSERVER_BASE_PATH + File.separator + "new-path";
 134
 135         File repoDir = clearRepoLocation( repoLocation );
 136
 137         mockAuditListener.clearEvents();
 138         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
 139         assertNotNull( repos );
 140         int initialSize = repos.size();
 141         assertTrue( initialSize > 0 );
 142
 143         ManagedRepository repo = new ManagedRepository();
 144         repo.setId( repoId );
 145         repo.setName( "test repo" );
 146         repo.setLocation( repoLocation );
 147         repo.setCronExpression( "0 0 * * * ?" );
 148         managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() );
 149
 150         assertTemplateRoleExists( repoId );
 151
 152         repos = managedRepositoryAdmin.getManagedRepositories();
 153         assertNotNull( repos );
 154         assertEquals( initialSize + 1, repos.size() );
 155
 156         String newName = "test repo update";
 157
 158         repo.setName( newName );
 159
 160         repo.setLocation( repoLocation );
 161         repo.setCronExpression( "0 0 * * * ?" );
 162
 163         managedRepositoryAdmin.updateManagedRepository( repo, false, getFakeAuditInformation(), false );
 164
 165         repo = managedRepositoryAdmin.getManagedRepository( repoId );
 166         assertNotNull( repo );
 167         assertEquals( newName, repo.getName() );
 168         assertEquals( new File( repoLocation ).getCanonicalPath(), new File( repo.getLocation() ).getCanonicalPath() );
 169         assertTrue( new File( repoLocation ).exists() );
 170
 171         assertTemplateRoleExists( repoId );
 172
 173         managedRepositoryAdmin.deleteManagedRepository( repo.getId(), getFakeAuditInformation(), false );
 174
 175         // check deleteContents false
 176         assertTrue( repoDir.exists() );
 177
 178         assertTemplateRoleNotExists( repoId );
 179
 180         assertAuditListenerCallAndUpdateAddAndDelete( false );
 181
 182         mockAuditListener.clearEvents();
 183
 184     }
 185
 186
 187     @Test
 188     public void addDeleteManagedRepoWithStaged()
 189         throws Exception
 190     {
 191
 192         String repoId = "test-new-one";
 193         String repoLocation = APPSERVER_BASE_PATH + File.separator + repoId;
 194
 195         File repoDir = clearRepoLocation( repoLocation );
 196
 197         mockAuditListener.clearEvents();
 198         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
 199         assertNotNull( repos );
 200         int initialSize = repos.size();
 201         assertTrue( initialSize > 0 );
 202
 203         ManagedRepository repo = new ManagedRepository();
 204         repo.setId( repoId );
 205         repo.setName( "test repo" );
 206         repo.setLocation( repoLocation );
 207         repo.setCronExpression( "0 0 * * * ?" );
 208         managedRepositoryAdmin.addManagedRepository( repo, true, getFakeAuditInformation() );
 209         repos = managedRepositoryAdmin.getManagedRepositories();
 210         assertNotNull( repos );
 211         assertEquals( initialSize + 2, repos.size() );
 212
 213         assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId ) );
 214
 215         assertTemplateRoleExists( repoId );
 216
 217         assertTrue( repoDir.exists() );
 218
 219         assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId + STAGE_REPO_ID_END ) );
 220
 221         assertTemplateRoleExists( repoId + STAGE_REPO_ID_END );
 222
 223         assertTrue( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
 224
 225         managedRepositoryAdmin.deleteManagedRepository( repoId, getFakeAuditInformation(), true );
 226
 227         assertFalse( repoDir.exists() );
 228
 229         assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
 230
 231         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 232
 233         repos = managedRepositoryAdmin.getManagedRepositories();
 234         assertNotNull( repos );
 235         assertEquals( initialSize, repos.size() );
 236
 237         assertTemplateRoleNotExists( repoId );
 238
 239         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 240
 241         mockAuditListener.clearEvents();
 242
 243     }
 244
 245     @Test
 246     public void updateDeleteManagedRepoWithStagedRepo()
 247         throws Exception
 248     {
 249         String repoId = "test-new-one";
 250
 251         String repoLocation = APPSERVER_BASE_PATH + File.separator + "new-path";
 252
 253         String stageRepoLocation = APPSERVER_BASE_PATH + File.separator + repoId;
 254
 255         File repoDir = clearRepoLocation( repoLocation );
 256
 257         mockAuditListener.clearEvents();
 258         List<ManagedRepository> repos = managedRepositoryAdmin.getManagedRepositories();
 259         assertNotNull( repos );
 260         int initialSize = repos.size();
 261         assertTrue( initialSize > 0 );
 262
 263         ManagedRepository repo = getTestManagedRepository( repoId, repoLocation );
 264
 265
 266
 267         managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() );
 268
 269         assertTemplateRoleExists( repoId );
 270
 271         assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
 272
 273         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 274
 275         repos = managedRepositoryAdmin.getManagedRepositories();
 276         assertNotNull( repos );
 277         assertEquals( initialSize + 1, repos.size() );
 278
 279         repo = managedRepositoryAdmin.getManagedRepository( repoId );
 280
 281         assertEquals( getTestManagedRepository( repoId, repoLocation ).getIndexDirectory(), repo.getIndexDirectory() );
 282
 283         String newName = "test repo update";
 284
 285         repo.setName( newName );
 286
 287         repo.setLocation( repoLocation );
 288
 289         managedRepositoryAdmin.updateManagedRepository( repo, true, getFakeAuditInformation(), false );
 290
 291         repo = managedRepositoryAdmin.getManagedRepository( repoId );
 292         assertNotNull( repo );
 293         assertEquals( newName, repo.getName() );
 294         assertEquals( new File( repoLocation ).getCanonicalPath(), new File( repo.getLocation() ).getCanonicalPath() );
 295         assertTrue( new File( repoLocation ).exists() );
 296         assertEquals( getTestManagedRepository( repoId, repoLocation ).getCronExpression(), repo.getCronExpression() );
 297         assertEquals( getTestManagedRepository( repoId, repoLocation ).getLayout(), repo.getLayout() );
 298         assertEquals( getTestManagedRepository( repoId, repoLocation ).getId(), repo.getId() );
 299         assertEquals( getTestManagedRepository( repoId, repoLocation ).getIndexDirectory(), repo.getIndexDirectory() );
 300
 301         assertEquals( getTestManagedRepository( repoId, repoLocation ).getDaysOlder(), repo.getDaysOlder() );
 302         assertEquals( getTestManagedRepository( repoId, repoLocation ).getRetentionCount(), repo.getRetentionCount() );
 303         assertEquals( getTestManagedRepository( repoId, repoLocation ).isDeleteReleasedSnapshots(),
 304                       repo.isDeleteReleasedSnapshots() );
 305
 306         assertTemplateRoleExists( repoId );
 307
 308         assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() );
 309
 310         assertTemplateRoleExists( repoId + STAGE_REPO_ID_END );
 311
 312         managedRepositoryAdmin.deleteManagedRepository( repo.getId(), getFakeAuditInformation(), false );
 313
 314         // check deleteContents false
 315         assertTrue( repoDir.exists() );
 316
 317         assertTemplateRoleNotExists( repoId );
 318
 319         assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() );
 320
 321         assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
 322
 323         assertAuditListenerCallAndUpdateAddAndDelete( true );
 324
 325         mockAuditListener.clearEvents();
 326
 327     }
 328
 329     //----------------------------------
 330     // utility methods
 331     //----------------------------------
 332
 333     private void assertTemplateRoleExists( String repoId )
 334         throws Exception
 335     {
 336         assertTrue( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) );
 337         assertTrue( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) );
 338     }
 339
 340
 341     private void assertTemplateRoleNotExists( String repoId )
 342         throws Exception
 343     {
 344         assertFalse( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) );
 345         assertFalse( roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) );
 346     }
 347
 348     private void assertAuditListenerCallAddAndDelete()
 349     {
 350         assertEquals( 2, mockAuditListener.getAuditEvents().size() );
 351
 352         assertEquals( AuditEvent.ADD_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 0 ).getAction() );
 353         assertEquals( "root", mockAuditListener.getAuditEvents().get( 0 ).getUserId() );
 354         assertEquals( "archiva-localhost", mockAuditListener.getAuditEvents().get( 0 ).getRemoteIP() );
 355
 356         assertEquals( AuditEvent.DELETE_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 357         assertEquals( "root", mockAuditListener.getAuditEvents().get( 0 ).getUserId() );
 358     }
 359
 360     private void assertAuditListenerCallAndUpdateAddAndDelete( boolean stageNeeded )
 361     {
 362         if ( stageNeeded )
 363         {
 364             assertEquals( "not 4 audit events " + mockAuditListener.getAuditEvents(), 4,
 365                           mockAuditListener.getAuditEvents().size() );
 366         }
 367         else
 368         {
 369             assertEquals( "not 3 audit events " + mockAuditListener.getAuditEvents(), 3,
 370                           mockAuditListener.getAuditEvents().size() );
 371         }
 372         assertEquals( AuditEvent.ADD_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 0 ).getAction() );
 373         assertEquals( "root", mockAuditListener.getAuditEvents().get( 0 ).getUserId() );
 374         assertEquals( "archiva-localhost", mockAuditListener.getAuditEvents().get( 0 ).getRemoteIP() );
 375
 376         if ( stageNeeded )
 377         {
 378             assertEquals( AuditEvent.ADD_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 379             assertEquals( AuditEvent.MODIFY_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 2 ).getAction() );
 380             assertEquals( AuditEvent.DELETE_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 3 ).getAction() );
 381         }
 382         else
 383         {
 384             assertEquals( AuditEvent.MODIFY_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 385             assertEquals( AuditEvent.DELETE_MANAGED_REPO, mockAuditListener.getAuditEvents().get( 2 ).getAction() );
 386         }
 387
 388     }
 389
 390     private File clearRepoLocation( String path )
 391         throws Exception
 392     {
 393         File repoDir = new File( path );
 394         if ( repoDir.exists() )
 395         {
 396             FileUtils.deleteDirectory( repoDir );
 397         }
 398         assertFalse( repoDir.exists() );
 399         return repoDir;
 400     }
 401
 402     private ManagedRepository findManagedRepoById( List<ManagedRepository> repos, String id )
 403     {
 404         for ( ManagedRepository repo : repos )
 405         {
 406             if ( StringUtils.equals( id, repo.getId() ) )
 407             {
 408                 return repo;
 409             }
 410         }
 411         return null;
 412     }
 413
 414
 415
 416     ManagedRepository getTestManagedRepository( String repoId, String repoLocation )
 417     {
 418         return new ManagedRepository( repoId, "test repo", repoLocation, "default", false, true, true, "0 0 * * * ?",
 419                                       repoLocation + "/.index", false, 1, 2, true );
 420     }
 421
 422 }