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