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