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