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

   1 package org.apache.archiva.configuration;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.test.utils.ArchivaBlockJUnit4ClassRunner;
  23 import org.junit.Test;
  24 import org.junit.runner.RunWith;
  25
  26 import java.util.Arrays;
  27 import java.util.HashSet;
  28 import java.util.Map;
  29
  30 import static org.junit.Assert.*;
  31
  32 /**
  33  * Test the generated Configuration class from Modello. This is primarily to test the hand coded methods.
  34  */
  35 @RunWith( ArchivaBlockJUnit4ClassRunner.class )
  36 public class ConfigurationTest
  37 {
  38     private Configuration configuration = new Configuration();
  39
  40     @Test
  41     public void testNetworkProxyRetrieval()
  42     {
  43         NetworkProxyConfiguration proxy1 = createNetworkProxy( "id1", "host1", 8080 );
  44         configuration.addNetworkProxy( proxy1 );
  45         NetworkProxyConfiguration proxy2 = createNetworkProxy( "id2", "host2", 9090 );
  46         configuration.addNetworkProxy( proxy2 );
  47
  48         Map<String, NetworkProxyConfiguration> map = configuration.getNetworkProxiesAsMap();
  49         assertNotNull( map );
  50         assertEquals( 2, map.size() );
  51         assertEquals( new HashSet<String>( Arrays.asList( "id1", "id2" ) ), map.keySet() );
  52         assertEquals( new HashSet<NetworkProxyConfiguration>( Arrays.asList( proxy1, proxy2 ) ),
  53                       new HashSet<NetworkProxyConfiguration>( map.values() ) );
  54     }
  55
  56     private NetworkProxyConfiguration createNetworkProxy( String id, String host, int port )
  57     {
  58         NetworkProxyConfiguration proxy = new NetworkProxyConfiguration();
  59         proxy.setId( id );
  60         proxy.setHost( host );
  61         proxy.setPort( port );
  62         proxy.setProtocol( "http" );
  63         return proxy;
  64     }
  65
  66     @Test
  67     public void testRemoteRepositoryRetrieval()
  68     {
  69         RemoteRepositoryConfiguration repo1 = createRemoteRepository( "id1", "name 1", "url 1" );
  70         configuration.addRemoteRepository( repo1 );
  71         RemoteRepositoryConfiguration repo2 = createRemoteRepository( "id2", "name 2", "url 2" );
  72         configuration.addRemoteRepository( repo2 );
  73
  74         Map<String, RemoteRepositoryConfiguration> map = configuration.getRemoteRepositoriesAsMap();
  75         assertNotNull( map );
  76         assertEquals( 2, map.size() );
  77         assertEquals( new HashSet<String>( Arrays.asList( "id1", "id2" ) ), map.keySet() );
  78         assertEquals( new HashSet<RemoteRepositoryConfiguration>( Arrays.asList( repo1, repo2 ) ),
  79                       new HashSet<RemoteRepositoryConfiguration>( map.values() ) );
  80
  81         assertEquals( repo1, configuration.findRemoteRepositoryById( "id1" ) );
  82         assertEquals( repo2, configuration.findRemoteRepositoryById( "id2" ) );
  83         assertNull( configuration.findRemoteRepositoryById( "id3" ) );
  84     }
  85
  86     private RemoteRepositoryConfiguration createRemoteRepository( String id, String name, String url )
  87     {
  88         RemoteRepositoryConfiguration repo = new RemoteRepositoryConfiguration();
  89         repo.setId( id );
  90         repo.setName( name );
  91         repo.setLayout( "default" );
  92         repo.setUrl( url );
  93         return repo;
  94     }
  95
  96     @Test
  97     public void testManagedRepositoryRetrieval()
  98     {
  99         ManagedRepositoryConfiguration repo1 = createManagedRepository( "id1", "name 1", "path 1", false );
 100         configuration.addManagedRepository( repo1 );
 101         ManagedRepositoryConfiguration repo2 = createManagedRepository( "id2", "name 2", "path 2", true );
 102         configuration.addManagedRepository( repo2 );
 103
 104         Map<String, ManagedRepositoryConfiguration> map = configuration.getManagedRepositoriesAsMap();
 105         assertNotNull( map );
 106         assertEquals( 2, map.size() );
 107         assertEquals( new HashSet<String>( Arrays.asList( "id1", "id2" ) ), map.keySet() );
 108         assertEquals( new HashSet<ManagedRepositoryConfiguration>( Arrays.asList( repo1, repo2 ) ),
 109                       new HashSet<ManagedRepositoryConfiguration>( map.values() ) );
 110
 111         assertEquals( repo1, configuration.findManagedRepositoryById( "id1" ) );
 112         assertEquals( repo2, configuration.findManagedRepositoryById( "id2" ) );
 113         assertNull( configuration.findManagedRepositoryById( "id3" ) );
 114     }
 115
 116     private ManagedRepositoryConfiguration createManagedRepository( String id, String name, String location,
 117                                                                     boolean scanned )
 118     {
 119         ManagedRepositoryConfiguration repo = new ManagedRepositoryConfiguration();
 120         repo.setId( id );
 121         repo.setName( name );
 122         repo.setLocation( location );
 123         repo.setScanned( scanned );
 124         return repo;
 125     }
 126
 127     @Test
 128     public void testNetworkProxyRetrievalWhenEmpty()
 129     {
 130         Map<String, NetworkProxyConfiguration> map = configuration.getNetworkProxiesAsMap();
 131         assertNotNull( map );
 132         assertTrue( map.isEmpty() );
 133     }
 134
 135     @Test
 136     public void testRemoteRepositoryRetrievalWhenEmpty()
 137     {
 138         Map<String, RemoteRepositoryConfiguration> map = configuration.getRemoteRepositoriesAsMap();
 139         assertNotNull( map );
 140         assertTrue( map.isEmpty() );
 141
 142         assertNull( configuration.findRemoteRepositoryById( "id" ) );
 143     }
 144
 145     @Test
 146     public void testManagedRepositoryRetrievalWhenEmpty()
 147     {
 148         Map<String, ManagedRepositoryConfiguration> map = configuration.getManagedRepositoriesAsMap();
 149         assertNotNull( map );
 150         assertTrue( map.isEmpty() );
 151
 152         assertNull( configuration.findManagedRepositoryById( "id" ) );
 153     }
 154 }