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

   1 package org.apache.archiva.admin.repository.admin;
   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.RepositoryAdminException;
  22 import org.apache.archiva.admin.model.admin.ArchivaAdministration;
  23 import org.apache.archiva.admin.model.beans.FileType;
  24 import org.apache.archiva.admin.model.beans.LegacyArtifactPath;
  25 import org.apache.archiva.admin.model.beans.NetworkConfiguration;
  26 import org.apache.archiva.admin.model.beans.OrganisationInformation;
  27 import org.apache.archiva.admin.model.beans.UiConfiguration;
  28 import org.apache.archiva.admin.repository.AbstractRepositoryAdminTest;
  29 import org.apache.archiva.metadata.model.facets.AuditEvent;
  30 import org.junit.Test;
  31
  32 import javax.inject.Inject;
  33 import java.util.Arrays;
  34
  35 /**
  36  * @author Olivier Lamy
  37  */
  38 public class ArchivaAdministrationTest
  39     extends AbstractRepositoryAdminTest
  40 {
  41     @Inject
  42     ArchivaAdministration archivaAdministration;
  43
  44
  45     @Test
  46     public void getAllLegacyPaths()
  47         throws Exception
  48     {
  49         assertNotNull( archivaAdministration.getLegacyArtifactPaths() );
  50         assertFalse( archivaAdministration.getLegacyArtifactPaths().isEmpty() );
  51         assertEquals( 1, archivaAdministration.getLegacyArtifactPaths().size() );
  52         log.info( "all legacy paths {}", archivaAdministration.getLegacyArtifactPaths() );
  53     }
  54
  55     public void addAndDeleteLegacyPath()
  56         throws Exception
  57     {
  58         int initialSize = archivaAdministration.getLegacyArtifactPaths().size();
  59
  60         LegacyArtifactPath legacyArtifactPath = new LegacyArtifactPath( "foo", "bar" );
  61         archivaAdministration.addLegacyArtifactPath( legacyArtifactPath, getFakeAuditInformation() );
  62
  63         assertTrue( archivaAdministration.getLegacyArtifactPaths().contains( new LegacyArtifactPath( "foo", "bar" ) ) );
  64         assertEquals( initialSize + 1, archivaAdministration.getLegacyArtifactPaths().size() );
  65
  66         archivaAdministration.deleteLegacyArtifactPath( legacyArtifactPath.getPath(), getFakeAuditInformation() );
  67
  68         assertFalse(
  69             archivaAdministration.getLegacyArtifactPaths().contains( new LegacyArtifactPath( "foo", "bar" ) ) );
  70         assertEquals( initialSize, archivaAdministration.getLegacyArtifactPaths().size() );
  71         mockAuditListener.clearEvents();
  72     }
  73
  74     @Test
  75     public void addAndUpdateAndDeleteFileType()
  76         throws RepositoryAdminException
  77     {
  78         int initialSize = archivaAdministration.getFileTypes().size();
  79
  80         FileType fileType = new FileType();
  81         fileType.setId( "foo" );
  82         fileType.setPatterns( Arrays.asList( "bar", "toto" ) );
  83
  84         archivaAdministration.addFileType( fileType, getFakeAuditInformation() );
  85
  86         assertEquals( initialSize + 1, archivaAdministration.getFileTypes().size() );
  87
  88         archivaAdministration.addFileTypePattern( "foo", "zorro", getFakeAuditInformation() );
  89
  90         assertEquals( initialSize + 1, archivaAdministration.getFileTypes().size() );
  91
  92         assertEquals( 3, archivaAdministration.getFileType( "foo" ).getPatterns().size() );
  93
  94         assertTrue( archivaAdministration.getFileType( "foo" ).getPatterns().contains( "bar" ) );
  95         assertTrue( archivaAdministration.getFileType( "foo" ).getPatterns().contains( "toto" ) );
  96         assertTrue( archivaAdministration.getFileType( "foo" ).getPatterns().contains( "zorro" ) );
  97
  98         archivaAdministration.removeFileTypePattern( "foo", "zorro", getFakeAuditInformation() );
  99
 100         assertEquals( initialSize + 1, archivaAdministration.getFileTypes().size() );
 101
 102         assertEquals( 2, archivaAdministration.getFileType( "foo" ).getPatterns().size() );
 103
 104         assertTrue( archivaAdministration.getFileType( "foo" ).getPatterns().contains( "bar" ) );
 105         assertTrue( archivaAdministration.getFileType( "foo" ).getPatterns().contains( "toto" ) );
 106         assertFalse( archivaAdministration.getFileType( "foo" ).getPatterns().contains( "zorro" ) );
 107
 108         archivaAdministration.removeFileType( "foo", getFakeAuditInformation() );
 109
 110         assertEquals( initialSize, archivaAdministration.getFileTypes().size() );
 111         assertNull( archivaAdministration.getFileType( "foo" ) );
 112         mockAuditListener.clearEvents();
 113     }
 114
 115     @Test(expected = RepositoryAdminException.class)
 116     public void addFileTypePatternAgain()
 117         throws RepositoryAdminException
 118     {
 119         try
 120         {
 121             archivaAdministration.addFileTypePattern( "artifacts", "**/*.jar", getFakeAuditInformation() );
 122         }
 123         catch ( RepositoryAdminException e )
 124         {
 125             // check the message
 126             assertEquals( "File type [artifacts] already contains pattern [**/*.jar]", e.getMessage() );
 127             throw e;
 128         }
 129     }
 130
 131     @Test
 132     public void knownContentConsumersTest()
 133         throws Exception
 134     {
 135         int initialSize = archivaAdministration.getKnownContentConsumers().size();
 136
 137         archivaAdministration.addKnownContentConsumer( "foo", getFakeAuditInformation() );
 138
 139         assertEquals( initialSize + 1, archivaAdministration.getKnownContentConsumers().size() );
 140         assertTrue( archivaAdministration.getKnownContentConsumers().contains( "foo" ) );
 141
 142         // ensure we don't add it twice as it's an ArrayList as storage
 143         archivaAdministration.addKnownContentConsumer( "foo", getFakeAuditInformation() );
 144
 145         assertEquals( initialSize + 1, archivaAdministration.getKnownContentConsumers().size() );
 146         assertTrue( archivaAdministration.getKnownContentConsumers().contains( "foo" ) );
 147
 148         archivaAdministration.removeKnownContentConsumer( "foo", getFakeAuditInformation() );
 149
 150         assertEquals( initialSize, archivaAdministration.getKnownContentConsumers().size() );
 151         assertFalse( archivaAdministration.getKnownContentConsumers().contains( "foo" ) );
 152
 153         assertEquals( 2, mockAuditListener.getAuditEvents().size() );
 154         assertEquals( AuditEvent.ENABLE_REPO_CONSUMER, mockAuditListener.getAuditEvents().get( 0 ).getAction() );
 155         assertEquals( AuditEvent.DISABLE_REPO_CONSUMER, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 156
 157         mockAuditListener.clearEvents();
 158
 159     }
 160
 161     @Test
 162     public void invalidContentConsumersTest()
 163         throws Exception
 164     {
 165         int initialSize = archivaAdministration.getInvalidContentConsumers().size();
 166
 167         archivaAdministration.addInvalidContentConsumer( "foo", getFakeAuditInformation() );
 168
 169         assertEquals( initialSize + 1, archivaAdministration.getInvalidContentConsumers().size() );
 170         assertTrue( archivaAdministration.getInvalidContentConsumers().contains( "foo" ) );
 171
 172         // ensure we don't add it twice as it's an ArrayList as storage
 173         archivaAdministration.addInvalidContentConsumer( "foo", getFakeAuditInformation() );
 174
 175         assertEquals( initialSize + 1, archivaAdministration.getInvalidContentConsumers().size() );
 176         assertTrue( archivaAdministration.getInvalidContentConsumers().contains( "foo" ) );
 177
 178         archivaAdministration.removeInvalidContentConsumer( "foo", getFakeAuditInformation() );
 179
 180         assertEquals( initialSize, archivaAdministration.getInvalidContentConsumers().size() );
 181         assertFalse( archivaAdministration.getInvalidContentConsumers().contains( "foo" ) );
 182
 183         assertEquals( 2, mockAuditListener.getAuditEvents().size() );
 184         assertEquals( AuditEvent.ENABLE_REPO_CONSUMER, mockAuditListener.getAuditEvents().get( 0 ).getAction() );
 185         assertEquals( AuditEvent.DISABLE_REPO_CONSUMER, mockAuditListener.getAuditEvents().get( 1 ).getAction() );
 186
 187         mockAuditListener.clearEvents();
 188
 189     }
 190
 191     @Test
 192     public void organisationInfoUpdate()
 193         throws Exception
 194     {
 195         OrganisationInformation oldOrganisationInformation = archivaAdministration.getOrganisationInformation();
 196         assertNotNull( oldOrganisationInformation );
 197         assertNull( oldOrganisationInformation.getLogoLocation() );
 198         assertNull( oldOrganisationInformation.getName() );
 199         assertNull( oldOrganisationInformation.getUrl() );
 200
 201         OrganisationInformation newOrganisationInformation = new OrganisationInformation();
 202         newOrganisationInformation.setLogoLocation( "http://foo.com/bar.png" );
 203         newOrganisationInformation.setName( "foo org" );
 204         newOrganisationInformation.setUrl( "http://foo.com" );
 205
 206         archivaAdministration.setOrganisationInformation( newOrganisationInformation );
 207
 208         newOrganisationInformation = archivaAdministration.getOrganisationInformation();
 209         assertNotNull( newOrganisationInformation );
 210         assertEquals( "http://foo.com/bar.png", newOrganisationInformation.getLogoLocation() );
 211         assertEquals( "foo org", newOrganisationInformation.getName() );
 212         assertEquals( "http://foo.com", newOrganisationInformation.getUrl() );
 213
 214         // back to initial OrganisationInformation //MRM-1638
 215         archivaAdministration.setOrganisationInformation( oldOrganisationInformation );
 216
 217     }
 218
 219     @Test
 220     public void badOrganisationInfoLogoLocation( )
 221     {
 222         try
 223         {
 224             OrganisationInformation newOrganisationInformation = new OrganisationInformation( );
 225             newOrganisationInformation.setLogoLocation( "'/><svg/onload=alert(/logoLocation_xss/)>" );
 226             newOrganisationInformation.setName( "foo org" );
 227             newOrganisationInformation.setUrl( "http://foo.com" );
 228             archivaAdministration.setOrganisationInformation( newOrganisationInformation );
 229             fail( "RepositoryAdminException expected. Bad URL content should not be allowed for logo location." );
 230         }
 231         catch ( RepositoryAdminException e )
 232         {
 233             // OK
 234         }
 235     }
 236
 237     @Test
 238     public void badOrganisationInfoUrl( )
 239     {
 240         try
 241         {
 242             OrganisationInformation newOrganisationInformation = new OrganisationInformation( );
 243             newOrganisationInformation.setUrl( "'/><svg/onload=alert(/url_xss/)>" );
 244             newOrganisationInformation.setName( "foo org" );
 245             newOrganisationInformation.setLogoLocation( "http://foo.com/bar.png" );
 246             archivaAdministration.setOrganisationInformation( newOrganisationInformation );
 247             fail( "RepositoryAdminException expected. Bad URL content should not be allowed for logo location." );
 248         }
 249         catch ( RepositoryAdminException e )
 250         {
 251             // OK
 252         }
 253
 254     }
 255
 256     @Test
 257     public void uiConfiguration()
 258         throws Exception
 259     {
 260         UiConfiguration oldUi = archivaAdministration.getUiConfiguration();
 261         assertNotNull( oldUi );
 262         // assert default values
 263         assertFalse( oldUi.isDisableEasterEggs() );
 264         assertTrue( oldUi.isAppletFindEnabled() );
 265         assertTrue( oldUi.isShowFindArtifacts() );
 266         assertFalse( oldUi.isDisableRegistration() );
 267
 268         UiConfiguration ui = archivaAdministration.getUiConfiguration();
 269         ui.setAppletFindEnabled( false );
 270         ui.setShowFindArtifacts( false );
 271         ui.setDisableEasterEggs( true );
 272         ui.setDisableRegistration( true );
 273
 274         archivaAdministration.updateUiConfiguration( ui );
 275
 276         ui = archivaAdministration.getUiConfiguration();
 277
 278         assertTrue( ui.isDisableEasterEggs() );
 279         assertFalse( ui.isAppletFindEnabled() );
 280         assertFalse( ui.isShowFindArtifacts() );
 281         assertTrue( ui.isDisableRegistration() );
 282
 283         archivaAdministration.updateUiConfiguration( oldUi );
 284     }
 285
 286     @Test
 287     public void networkConfiguration()
 288         throws Exception
 289     {
 290         NetworkConfiguration networkConfiguration = archivaAdministration.getNetworkConfiguration();
 291         assertNotNull( networkConfiguration );
 292
 293         assertTrue( networkConfiguration.isUsePooling() );
 294         assertEquals( 30, networkConfiguration.getMaxTotal() );
 295         assertEquals( 30, networkConfiguration.getMaxTotalPerHost() );
 296
 297     }
 298 }