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

   1 package org.apache.archiva.web.rss;
   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
  23 import junit.framework.TestCase;
  24 import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
  25 import org.apache.commons.codec.Encoder;
  26 import org.apache.commons.codec.binary.Base64;
  27 import org.junit.After;
  28 import org.junit.AfterClass;
  29 import org.junit.Before;
  30 import org.junit.BeforeClass;
  31 import org.junit.Ignore;
  32 import org.junit.Test;
  33 import org.junit.runner.RunWith;
  34 import org.springframework.beans.BeansException;
  35 import org.springframework.beans.factory.BeanFactory;
  36 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
  37 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
  38 import org.springframework.context.ApplicationContext;
  39 import org.springframework.context.ApplicationEvent;
  40 import org.springframework.context.MessageSourceResolvable;
  41 import org.springframework.context.NoSuchMessageException;
  42 import org.springframework.core.env.Environment;
  43 import org.springframework.core.io.Resource;
  44 import org.springframework.mock.web.MockHttpServletRequest;
  45 import org.springframework.mock.web.MockHttpServletResponse;
  46 import org.springframework.mock.web.MockServletConfig;
  47 import org.springframework.mock.web.MockServletContext;
  48 import org.springframework.test.context.ContextConfiguration;
  49 import org.springframework.web.context.WebApplicationContext;
  50
  51 import javax.inject.Inject;
  52 import javax.servlet.ServletContext;
  53 import javax.servlet.http.HttpServletResponse;
  54 import java.io.IOException;
  55 import java.lang.annotation.Annotation;
  56 import java.util.Locale;
  57 import java.util.Map;
  58
  59 @RunWith( ArchivaSpringJUnit4ClassRunner.class )
  60 @ContextConfiguration(
  61     locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:/spring-context-test-common.xml",
  62         "classpath*:/spring-context-rss-servlet.xml" } )
  63 public class RssFeedServletTest
  64     extends TestCase
  65 {
  66     private RssFeedServlet rssFeedServlet = new RssFeedServlet();
  67
  68     static String PREVIOUS_ARCHIVA_PATH;
  69
  70     @Inject
  71     protected ApplicationContext applicationContext;
  72
  73     @BeforeClass
  74     public static void initConfigurationPath()
  75         throws Exception
  76     {
  77         PREVIOUS_ARCHIVA_PATH = System.getProperty( "archiva.user.configFileName" );
  78         System.setProperty( "archiva.user.configFileName",
  79                             System.getProperty( "test.resources.path/" ) + "empty-archiva.xml" );
  80     }
  81
  82
  83     @AfterClass
  84     public static void restoreConfigurationPath()
  85         throws Exception
  86     {
  87         System.setProperty( "archiva.user.configFileName", PREVIOUS_ARCHIVA_PATH );
  88     }
  89
  90     @Before
  91     @Override
  92     public void setUp()
  93         throws Exception
  94     {
  95         final MockServletContext mockServletContext = new MockServletContext();
  96
  97         WebApplicationContext webApplicationContext =
  98             new TestWebapplicationContext( applicationContext, mockServletContext );
  99
 100         mockServletContext.setAttribute( WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,
 101                                          webApplicationContext );
 102
 103         MockServletConfig mockServletConfig = new MockServletConfig()
 104         {
 105             @Override
 106             public ServletContext getServletContext()
 107             {
 108                 return mockServletContext;
 109             }
 110         };
 111
 112         rssFeedServlet.init( mockServletConfig );
 113     }
 114
 115     @After
 116     @Override
 117     public void tearDown()
 118         throws Exception
 119     {
 120         super.tearDown();
 121     }
 122
 123     public static class TestWebapplicationContext
 124         implements WebApplicationContext
 125     {
 126         private ApplicationContext applicationContext;
 127
 128         private ServletContext servletContext;
 129
 130         TestWebapplicationContext( ApplicationContext applicationContext, ServletContext servletContext )
 131         {
 132             this.applicationContext = applicationContext;
 133         }
 134
 135         @Override
 136         public ServletContext getServletContext()
 137         {
 138             return servletContext;
 139         }
 140
 141         @Override
 142         public String getId()
 143         {
 144             return applicationContext.getId();
 145         }
 146
 147         @Override
 148         public String getApplicationName()
 149         {
 150             return applicationContext.getApplicationName();
 151         }
 152
 153         @Override
 154         public String getDisplayName()
 155         {
 156             return applicationContext.getDisplayName();
 157         }
 158
 159         @Override
 160         public long getStartupDate()
 161         {
 162             return applicationContext.getStartupDate();
 163         }
 164
 165         @Override
 166         public ApplicationContext getParent()
 167         {
 168             return applicationContext.getParent();
 169         }
 170
 171         @Override
 172         public AutowireCapableBeanFactory getAutowireCapableBeanFactory()
 173             throws IllegalStateException
 174         {
 175             return applicationContext.getAutowireCapableBeanFactory();
 176         }
 177
 178         @Override
 179         public void publishEvent( ApplicationEvent applicationEvent )
 180         {
 181             applicationContext.publishEvent( applicationEvent );
 182         }
 183
 184         @Override
 185         public Environment getEnvironment()
 186         {
 187             return applicationContext.getEnvironment();
 188         }
 189
 190         @Override
 191         public BeanFactory getParentBeanFactory()
 192         {
 193             return applicationContext.getParentBeanFactory();
 194         }
 195
 196         @Override
 197         public boolean containsLocalBean( String s )
 198         {
 199             return applicationContext.containsLocalBean( s );
 200         }
 201
 202         @Override
 203         public boolean containsBeanDefinition( String s )
 204         {
 205             return applicationContext.containsBeanDefinition( s );
 206         }
 207
 208         @Override
 209         public int getBeanDefinitionCount()
 210         {
 211             return applicationContext.getBeanDefinitionCount();
 212         }
 213
 214         @Override
 215         public String[] getBeanDefinitionNames()
 216         {
 217             return applicationContext.getBeanDefinitionNames();
 218         }
 219
 220         @Override
 221         public String[] getBeanNamesForType( Class<?> aClass )
 222         {
 223             return applicationContext.getBeanNamesForType( aClass );
 224         }
 225
 226         @Override
 227         public String[] getBeanNamesForType( Class<?> aClass, boolean b, boolean b2 )
 228         {
 229             return applicationContext.getBeanNamesForType( aClass, b, b2 );
 230         }
 231
 232         @Override
 233         public <T> Map<String, T> getBeansOfType( Class<T> tClass )
 234             throws BeansException
 235         {
 236             return applicationContext.getBeansOfType( tClass );
 237         }
 238
 239         @Override
 240         public <T> T getBean( Class<T> aClass, Object... objects )
 241             throws BeansException
 242         {
 243             return applicationContext.getBean( aClass, objects );
 244         }
 245
 246         @Override
 247         public <T> Map<String, T> getBeansOfType( Class<T> tClass, boolean b, boolean b2 )
 248             throws BeansException
 249         {
 250             return applicationContext.getBeansOfType( tClass, b, b2 );
 251         }
 252
 253         @Override
 254         public String[] getBeanNamesForAnnotation( Class<? extends Annotation> aClass )
 255         {
 256             return applicationContext.getBeanNamesForAnnotation( aClass );
 257         }
 258
 259         @Override
 260         public Map<String, Object> getBeansWithAnnotation( Class<? extends Annotation> aClass )
 261             throws BeansException
 262         {
 263             return applicationContext.getBeansWithAnnotation( aClass );
 264         }
 265
 266         @Override
 267         public <A extends Annotation> A findAnnotationOnBean( String s, Class<A> aClass )
 268             throws NoSuchBeanDefinitionException
 269         {
 270             return applicationContext.findAnnotationOnBean( s, aClass );
 271         }
 272
 273         @Override
 274         public Object getBean( String s )
 275             throws BeansException
 276         {
 277             return applicationContext.getBean( s );
 278         }
 279
 280         @Override
 281         public <T> T getBean( String s, Class<T> tClass )
 282             throws BeansException
 283         {
 284             return applicationContext.getBean( s, tClass );
 285         }
 286
 287         @Override
 288         public <T> T getBean( Class<T> tClass )
 289             throws BeansException
 290         {
 291             return applicationContext.getBean( tClass );
 292         }
 293
 294         @Override
 295         public Object getBean( String s, Object... objects )
 296             throws BeansException
 297         {
 298             return applicationContext.getBean( s, objects );
 299         }
 300
 301         @Override
 302         public boolean containsBean( String s )
 303         {
 304             return applicationContext.containsBean( s );
 305         }
 306
 307         @Override
 308         public boolean isSingleton( String s )
 309             throws NoSuchBeanDefinitionException
 310         {
 311             return applicationContext.isSingleton( s );
 312         }
 313
 314         @Override
 315         public boolean isPrototype( String s )
 316             throws NoSuchBeanDefinitionException
 317         {
 318             return applicationContext.isPrototype( s );
 319         }
 320
 321         @Override
 322         public boolean isTypeMatch( String s, Class<?> aClass )
 323             throws NoSuchBeanDefinitionException
 324         {
 325             return applicationContext.isTypeMatch( s, aClass );
 326         }
 327
 328         @Override
 329         public Class<?> getType( String s )
 330             throws NoSuchBeanDefinitionException
 331         {
 332             return applicationContext.getType( s );
 333         }
 334
 335         @Override
 336         public String[] getAliases( String s )
 337         {
 338             return applicationContext.getAliases( s );
 339         }
 340
 341         @Override
 342         public String getMessage( String s, Object[] objects, String s2, Locale locale )
 343         {
 344             return applicationContext.getMessage( s, objects, s2, locale );
 345         }
 346
 347         @Override
 348         public String getMessage( String s, Object[] objects, Locale locale )
 349             throws NoSuchMessageException
 350         {
 351             return applicationContext.getMessage( s, objects, locale );
 352         }
 353
 354         @Override
 355         public String getMessage( MessageSourceResolvable messageSourceResolvable, Locale locale )
 356             throws NoSuchMessageException
 357         {
 358             return applicationContext.getMessage( messageSourceResolvable, locale );
 359         }
 360
 361         @Override
 362         public Resource[] getResources( String s )
 363             throws IOException
 364         {
 365             return applicationContext.getResources( s );
 366         }
 367
 368         @Override
 369         public Resource getResource( String s )
 370         {
 371             return applicationContext.getResource( s );
 372         }
 373
 374         @Override
 375         public ClassLoader getClassLoader()
 376         {
 377             return applicationContext.getClassLoader();
 378         }
 379     }
 380
 381
 382     @Test
 383     public void testRequestNewArtifactsInRepo()
 384         throws Exception
 385     {
 386         MockHttpServletRequest request = new MockHttpServletRequest();
 387         request.setRequestURI( "/feeds/test-repo" );
 388         request.addHeader( "User-Agent", "Apache Archiva unit test" );
 389         request.setMethod( "GET" );
 390
 391         Base64 encoder = new Base64( 0, new byte[0] );
 392         String userPass = "user1:password1";
 393         String encodedUserPass = encoder.encodeToString( userPass.getBytes() );
 394         request.addHeader( "Authorization", "BASIC " + encodedUserPass );
 395
 396         MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
 397
 398         rssFeedServlet.doGet( request, mockHttpServletResponse );
 399
 400         assertEquals( RssFeedServlet.MIME_TYPE, mockHttpServletResponse.getHeader( "CONTENT-TYPE" ) );
 401         assertNotNull( "Should have recieved a response", mockHttpServletResponse.getContentAsString() );
 402         assertEquals( "Should have been an OK response code.", HttpServletResponse.SC_OK,
 403                       mockHttpServletResponse.getStatus() );
 404
 405     }
 406
 407     @Test
 408     public void testRequestNewVersionsOfArtifact()
 409         throws Exception
 410     {
 411         MockHttpServletRequest request = new MockHttpServletRequest();
 412         request.setRequestURI( "/feeds/org/apache/archiva/artifact-two" );
 413         request.addHeader( "User-Agent", "Apache Archiva unit test" );
 414         request.setMethod( "GET" );
 415
 416         //WebRequest request = new GetMethodWebRequest( "http://localhost/feeds/org/apache/archiva/artifact-two" );
 417
 418         Base64 encoder = new Base64( 0, new byte[0] );
 419         String userPass = "user1:password1";
 420         String encodedUserPass = encoder.encodeToString( userPass.getBytes() );
 421         request.addHeader( "Authorization", "BASIC " + encodedUserPass );
 422
 423         MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
 424
 425         rssFeedServlet.doGet( request, mockHttpServletResponse );
 426
 427         assertEquals( RssFeedServlet.MIME_TYPE, mockHttpServletResponse.getHeader( "CONTENT-TYPE" ) );
 428         assertNotNull( "Should have recieved a response", mockHttpServletResponse.getContentAsString() );
 429         assertEquals( "Should have been an OK response code.", HttpServletResponse.SC_OK,
 430                       mockHttpServletResponse.getStatus() );
 431     }
 432
 433     @Ignore
 434     public void XXX_testInvalidRequest()
 435         throws Exception
 436     {
 437         //RssFeedServlet servlet =
 438         //    (RssFeedServlet) client.newInvocation( "http://localhost/feeds?invalid_param=xxx" ).getServlet();
 439         MockHttpServletRequest request = new MockHttpServletRequest();
 440         request.setRequestURI( "/feeds?invalid_param=xxx" );
 441         request.addHeader( "User-Agent", "Apache Archiva unit test" );
 442         request.setMethod( "GET" );
 443
 444         MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
 445
 446         rssFeedServlet.doGet( request, mockHttpServletResponse );
 447
 448         assertEquals( HttpServletResponse.SC_BAD_REQUEST, mockHttpServletResponse.getStatus() );
 449
 450     }
 451
 452     @Ignore
 453     public void XXX_testInvalidAuthenticationRequest()
 454         throws Exception
 455     {
 456         //RssFeedServlet servlet =
 457         //    (RssFeedServlet) client.newInvocation( "http://localhost/feeds/unauthorized-repo" ).getServlet();
 458
 459         //WebRequest request = new GetMethodWebRequest( "http://localhost/feeds/unauthorized-repo" );
 460
 461         MockHttpServletRequest request = new MockHttpServletRequest();
 462         request.setRequestURI( "/feeds/unauthorized-repo" );
 463         request.addHeader( "User-Agent", "Apache Archiva unit test" );
 464         request.setMethod( "GET" );
 465
 466         Encoder encoder = new Base64();
 467         String userPass = "unauthUser:unauthPass";
 468         String encodedUserPass = new String( (byte[]) encoder.encode( userPass.getBytes() ) );
 469         request.addHeader( "Authorization", "BASIC " + encodedUserPass );
 470
 471         MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
 472         rssFeedServlet.doGet( request, mockHttpServletResponse );
 473
 474         assertEquals( HttpServletResponse.SC_UNAUTHORIZED, mockHttpServletResponse.getStatus() );
 475
 476     }
 477
 478     @Ignore
 479     public void XXX_testUnauthorizedRequest()
 480         throws Exception
 481     {
 482
 483         MockHttpServletRequest request = new MockHttpServletRequest();
 484         request.setRequestURI( "/feeds/unauthorized-repo" );
 485         request.addHeader( "User-Agent", "Apache Archiva unit test" );
 486         request.setMethod( "GET" );
 487
 488         //WebRequest request = new GetMethodWebRequest( "http://localhost/feeds/unauthorized-repo" );
 489
 490         Base64 encoder = new Base64( 0, new byte[0] );
 491         String userPass = "user1:password1";
 492         String encodedUserPass = encoder.encodeToString( userPass.getBytes() );
 493         request.addHeader( "Authorization", "BASIC " + encodedUserPass );
 494
 495         MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
 496         rssFeedServlet.doGet( request, mockHttpServletResponse );
 497
 498         assertEquals( HttpServletResponse.SC_UNAUTHORIZED, mockHttpServletResponse.getStatus() );
 499
 500     }
 501
 502
 503 }