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

   1 package org.apache.archiva.webdav;
   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 com.gargoylesoftware.htmlunit.HttpMethod;
  23 import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController;
  24 import com.gargoylesoftware.htmlunit.WebClient;
  25 import com.gargoylesoftware.htmlunit.WebRequest;
  26 import com.gargoylesoftware.htmlunit.WebResponse;
  27 import junit.framework.Assert;
  28 import junit.framework.TestCase;
  29 import net.sf.ehcache.CacheManager;
  30 import org.apache.archiva.admin.model.beans.ManagedRepository;
  31 import org.apache.archiva.configuration.ArchivaConfiguration;
  32 import org.apache.archiva.configuration.Configuration;
  33 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  34 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  35 import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
  36 import org.apache.archiva.webdav.util.MavenIndexerCleaner;
  37 import org.apache.archiva.webdav.util.ReinitServlet;
  38 import org.apache.catalina.Container;
  39 import org.apache.catalina.Context;
  40 import org.apache.catalina.core.StandardContext;
  41 import org.apache.catalina.deploy.ApplicationParameter;
  42 import org.apache.catalina.startup.Tomcat;
  43 import org.apache.commons.io.FileUtils;
  44 import org.apache.commons.lang.StringUtils;
  45 import org.junit.After;
  46 import org.junit.Before;
  47 import org.junit.runner.RunWith;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50 import org.springframework.context.ApplicationContext;
  51 import org.springframework.test.context.ContextConfiguration;
  52 import org.springframework.web.context.ContextLoaderListener;
  53
  54 import javax.inject.Inject;
  55 import javax.servlet.Servlet;
  56 import javax.servlet.http.HttpServletResponse;
  57 import java.io.File;
  58 import java.io.IOException;
  59 import java.io.InputStream;
  60 import java.net.URL;
  61 import java.nio.charset.Charset;
  62
  63 /**
  64  * AbstractRepositoryServletTestCase
  65  */
  66 @RunWith(ArchivaSpringJUnit4ClassRunner.class)
  67 @ContextConfiguration(locations = { "classpath*:/repository-servlet-simple.xml" })
  68 public abstract class AbstractRepositoryServletTestCase
  69     extends TestCase
  70 {
  71     protected static final String REPOID_INTERNAL = "internal";
  72
  73     protected static final String REPOID_LEGACY = "legacy";
  74
  75     protected File repoRootInternal;
  76
  77     protected File repoRootLegacy;
  78
  79
  80     protected ArchivaConfiguration archivaConfiguration;
  81
  82     @Inject
  83     protected ApplicationContext applicationContext;
  84
  85     protected Logger log = LoggerFactory.getLogger( getClass() );
  86
  87
  88     protected void saveConfiguration()
  89         throws Exception
  90     {
  91         saveConfiguration( archivaConfiguration );
  92     }
  93
  94     protected Tomcat tomcat;
  95
  96     protected static int port;
  97
  98     @Before
  99     public void setUp()
 100         throws Exception
 101     {
 102
 103         super.setUp();
 104
 105         String appserverBase = new File( "target/appserver-base" ).getAbsolutePath();
 106         System.setProperty( "appserver.base", appserverBase );
 107
 108         File testConf = new File( "src/test/resources/repository-archiva.xml" );
 109         File testConfDest = new File( appserverBase, "conf/archiva.xml" );
 110         if ( testConfDest.exists() )
 111         {
 112             FileUtils.deleteQuietly( testConfDest );
 113         }
 114         FileUtils.copyFile( testConf, testConfDest );
 115
 116         archivaConfiguration = applicationContext.getBean( ArchivaConfiguration.class );
 117
 118         repoRootInternal = new File( appserverBase, "data/repositories/internal" );
 119         repoRootLegacy = new File( appserverBase, "data/repositories/legacy" );
 120         Configuration config = archivaConfiguration.getConfiguration();
 121
 122         config.getManagedRepositories().clear();
 123
 124         config.addManagedRepository(
 125             createManagedRepository( REPOID_INTERNAL, "Internal Test Repo", repoRootInternal, true ) );
 126
 127         config.addManagedRepository(
 128             createManagedRepository( REPOID_LEGACY, "Legacy Format Test Repo", repoRootLegacy, "legacy", true ) );
 129
 130         config.getProxyConnectors().clear();
 131
 132         config.getRemoteRepositories().clear();
 133
 134         saveConfiguration( archivaConfiguration );
 135
 136         CacheManager.getInstance().clearAll();
 137
 138         applicationContext.getBean( MavenIndexerCleaner.class ).cleanupIndex();
 139
 140
 141     }
 142
 143     StandardContext context;
 144
 145     UnauthenticatedRepositoryServlet servlet;
 146
 147     protected void startRepository()
 148         throws Exception
 149     {
 150         tomcat = new Tomcat();
 151         tomcat.setBaseDir( System.getProperty( "java.io.tmpdir" ) );
 152         tomcat.setPort( 0 );
 153
 154         context = (StandardContext) tomcat.addContext( "", System.getProperty( "java.io.tmpdir" ) );
 155
 156         ApplicationParameter applicationParameter = new ApplicationParameter();
 157         applicationParameter.setName( "contextConfigLocation" );
 158         applicationParameter.setValue( getSpringConfigLocation() );
 159         context.addApplicationParameter( applicationParameter );
 160
 161         context.addApplicationListener( ContextLoaderListener.class.getName() );
 162
 163         context.addApplicationListener( MavenIndexerCleaner.class.getName() );
 164
 165         servlet = new UnauthenticatedRepositoryServlet();
 166
 167         Tomcat.addServlet( context, "repository", servlet );
 168         context.addServletMapping( "/repository/*", "repository" );
 169
 170         Tomcat.addServlet( context, "reinitservlet", new ReinitServlet() );
 171         context.addServletMapping( "/reinit/*", "reinitservlet" );
 172
 173         tomcat.start();
 174
 175         this.port = tomcat.getConnector().getLocalPort();
 176     }
 177
 178     protected Servlet findServlet( String name )
 179         throws Exception
 180     {
 181         Container[] childs = context.findChildren();
 182         for ( Container container : childs )
 183         {
 184             if ( StringUtils.equals( container.getName(), name ) )
 185             {
 186                 Tomcat.ExistingStandardWrapper esw = Tomcat.ExistingStandardWrapper.class.cast( container );
 187                 Servlet servlet = esw.loadServlet();
 188
 189                 return servlet;
 190             }
 191         }
 192         return null;
 193     }
 194
 195     protected String getSpringConfigLocation()
 196     {
 197         return "classpath*:/META-INF/spring-context.xml,classpath*:spring-context.xml";
 198     }
 199
 200
 201
 202
 203     /*
 204     protected ServletUnitClient getServletUnitClient()
 205         throws Exception
 206     {
 207         if ( servletUnitClient != null )
 208         {
 209             return servletUnitClient;
 210         }
 211         servletRunner = new ServletRunner( new File( "src/test/resources/WEB-INF/web.xml" ) );
 212
 213         servletRunner.registerServlet( "/repository/*", UnauthenticatedRepositoryServlet.class.getName() );
 214
 215         servletUnitClient = servletRunner.newClient();
 216
 217         return servletUnitClient;
 218     }*/
 219
 220     /*
 221     protected <P extends Page> P page(final String path) throws IOException {
 222         return newClient().getPage(base.toExternalForm() + "repository/" + path);
 223     }
 224     */
 225
 226     protected static WebClient newClient()
 227     {
 228         final WebClient webClient = new WebClient();
 229         webClient.getOptions().setJavaScriptEnabled( false );
 230         webClient.getOptions().setCssEnabled( false );
 231         webClient.getOptions().setAppletEnabled( false );
 232         webClient.getOptions().setThrowExceptionOnFailingStatusCode( false );
 233         webClient.setAjaxController( new NicelyResynchronizingAjaxController() );
 234         return webClient;
 235     }
 236
 237
 238     protected static WebResponse getWebResponse( String path )
 239         throws Exception
 240     {
 241         WebClient client = newClient();
 242         client.getPage( "http://localhost:" + port + "/reinit/reload" );
 243         return client.getPage( "http://localhost:" + port + path ).getWebResponse();
 244     }
 245
 246     public static class GetMethodWebRequest
 247         extends WebRequest
 248     {
 249         String url;
 250
 251         public GetMethodWebRequest( String url )
 252             throws Exception
 253         {
 254             super( new URL( url ) );
 255             this.url = url;
 256
 257         }
 258     }
 259
 260     public static class PutMethodWebRequest
 261         extends WebRequest
 262     {
 263         String url;
 264
 265         public PutMethodWebRequest( String url, InputStream inputStream, String contentType )
 266             throws Exception
 267         {
 268             super( new URL( url ), HttpMethod.PUT );
 269             this.url = url;
 270
 271         }
 272
 273
 274     }
 275
 276     public static class ServletUnitClient
 277     {
 278
 279         public ServletUnitClient()
 280         {
 281
 282         }
 283
 284         public WebResponse getResponse( WebRequest request )
 285             throws Exception
 286         {
 287             return getWebResponse( request.getUrl().getPath() );
 288         }
 289
 290         public WebResponse getResource( WebRequest request )
 291             throws Exception
 292         {
 293             return getResponse( request );
 294         }
 295     }
 296
 297     public ServletUnitClient getServletUnitClient()
 298     {
 299         return new ServletUnitClient();
 300     }
 301
 302     @Override
 303     @After
 304     public void tearDown()
 305         throws Exception
 306     {
 307
 308         if ( repoRootInternal.exists() )
 309         {
 310             FileUtils.deleteDirectory( repoRootInternal );
 311         }
 312
 313         if ( repoRootLegacy.exists() )
 314         {
 315             FileUtils.deleteDirectory( repoRootLegacy );
 316         }
 317
 318         if ( this.tomcat != null )
 319         {
 320             this.tomcat.stop();
 321         }
 322
 323     }
 324
 325
 326     protected void assertFileContents( String expectedContents, File repoRoot, String path )
 327         throws IOException
 328     {
 329         File actualFile = new File( repoRoot, path );
 330         assertTrue( "File <" + actualFile.getAbsolutePath() + "> should exist.", actualFile.exists() );
 331         assertTrue( "File <" + actualFile.getAbsolutePath() + "> should be a file (not a dir/link/device/etc).",
 332                     actualFile.isFile() );
 333
 334         String actualContents = FileUtils.readFileToString( actualFile, Charset.defaultCharset() );
 335         assertEquals( "File Contents of <" + actualFile.getAbsolutePath() + ">", expectedContents, actualContents );
 336     }
 337
 338     protected void assertRepositoryValid( RepositoryServlet servlet, String repoId )
 339         throws Exception
 340     {
 341         ManagedRepository repository = servlet.getRepository( repoId );
 342         assertNotNull( "Archiva Managed Repository id:<" + repoId + "> should exist.", repository );
 343         File repoRoot = new File( repository.getLocation() );
 344         assertTrue( "Archiva Managed Repository id:<" + repoId + "> should have a valid location on disk.",
 345                     repoRoot.exists() && repoRoot.isDirectory() );
 346     }
 347
 348     protected void assertResponseOK( WebResponse response )
 349     {
 350
 351         assertNotNull( "Should have recieved a response", response );
 352         Assert.assertEquals( "Should have been an OK response code", HttpServletResponse.SC_OK,
 353                              response.getStatusCode() );
 354     }
 355
 356     protected void assertResponseOK( WebResponse response, String path )
 357     {
 358         assertNotNull( "Should have recieved a response", response );
 359         Assert.assertEquals( "Should have been an OK response code for path: " + path, HttpServletResponse.SC_OK,
 360                              response.getStatusCode() );
 361     }
 362
 363     protected void assertResponseNotFound( WebResponse response )
 364     {
 365         assertNotNull( "Should have recieved a response", response );
 366         Assert.assertEquals( "Should have been an 404/Not Found response code.", HttpServletResponse.SC_NOT_FOUND,
 367                              response.getStatusCode() );
 368     }
 369
 370     protected void assertResponseInternalServerError( WebResponse response )
 371     {
 372         assertNotNull( "Should have recieved a response", response );
 373         Assert.assertEquals( "Should have been an 500/Internal Server Error response code.",
 374                              HttpServletResponse.SC_INTERNAL_SERVER_ERROR, response.getStatusCode() );
 375     }
 376
 377     protected void assertResponseConflictError( WebResponse response )
 378     {
 379         assertNotNull( "Should have received a response", response );
 380         Assert.assertEquals( "Should have been a 409/Conflict response code.", HttpServletResponse.SC_CONFLICT,
 381                              response.getStatusCode() );
 382     }
 383
 384     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, File location,
 385                                                                       boolean blockRedeployments )
 386     {
 387         ManagedRepositoryConfiguration repo = new ManagedRepositoryConfiguration();
 388         repo.setId( id );
 389         repo.setName( name );
 390         repo.setLocation( location.getAbsolutePath() );
 391         repo.setBlockRedeployments( blockRedeployments );
 392
 393         return repo;
 394     }
 395
 396     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, File location,
 397                                                                       String layout, boolean blockRedeployments )
 398     {
 399         ManagedRepositoryConfiguration repo = createManagedRepository( id, name, location, blockRedeployments );
 400         repo.setLayout( layout );
 401         return repo;
 402     }
 403
 404     protected RemoteRepositoryConfiguration createRemoteRepository( String id, String name, String url )
 405     {
 406         RemoteRepositoryConfiguration repo = new RemoteRepositoryConfiguration();
 407         repo.setId( id );
 408         repo.setName( name );
 409         repo.setUrl( url );
 410         return repo;
 411     }
 412
 413     protected void saveConfiguration( ArchivaConfiguration archivaConfiguration )
 414         throws Exception
 415     {
 416         archivaConfiguration.save( archivaConfiguration.getConfiguration() );
 417     }
 418
 419
 420     protected void setupCleanRepo( File repoRootDir )
 421         throws IOException
 422     {
 423         FileUtils.deleteDirectory( repoRootDir );
 424         if ( !repoRootDir.exists() )
 425         {
 426             repoRootDir.mkdirs();
 427         }
 428     }
 429
 430     protected void assertManagedFileNotExists( File repoRootInternal, String resourcePath )
 431     {
 432         File repoFile = new File( repoRootInternal, resourcePath );
 433         assertFalse( "Managed Repository File <" + repoFile.getAbsolutePath() + "> should not exist.",
 434                      repoFile.exists() );
 435     }
 436
 437     protected void setupCleanInternalRepo()
 438         throws Exception
 439     {
 440         setupCleanRepo( repoRootInternal );
 441     }
 442
 443     protected File populateRepo( File repoRootManaged, String path, String contents )
 444         throws Exception
 445     {
 446         File destFile = new File( repoRootManaged, path );
 447         destFile.getParentFile().mkdirs();
 448         FileUtils.writeStringToFile( destFile, contents, Charset.defaultCharset() );
 449         return destFile;
 450     }
 451 }