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
  99     StandardContext context;
 100
 101     @Before
 102     public void setUp()
 103         throws Exception
 104     {
 105
 106         super.setUp();
 107
 108         String appserverBase = new File( "target/appserver-base" ).getAbsolutePath();
 109         System.setProperty( "appserver.base", appserverBase );
 110
 111         File testConf = new File( "src/test/resources/repository-archiva.xml" );
 112         File testConfDest = new File( appserverBase, "conf/archiva.xml" );
 113         if ( testConfDest.exists() )
 114         {
 115             FileUtils.deleteQuietly( testConfDest );
 116         }
 117         FileUtils.copyFile( testConf, testConfDest );
 118
 119         archivaConfiguration = applicationContext.getBean( ArchivaConfiguration.class );
 120
 121         repoRootInternal = new File( appserverBase, "data/repositories/internal" );
 122         repoRootLegacy = new File( appserverBase, "data/repositories/legacy" );
 123         Configuration config = archivaConfiguration.getConfiguration();
 124
 125         config.getManagedRepositories().clear();
 126
 127         config.addManagedRepository(
 128             createManagedRepository( REPOID_INTERNAL, "Internal Test Repo", repoRootInternal, true ) );
 129
 130         config.addManagedRepository(
 131             createManagedRepository( REPOID_LEGACY, "Legacy Format Test Repo", repoRootLegacy, "legacy", true ) );
 132
 133         config.getProxyConnectors().clear();
 134
 135         config.getRemoteRepositories().clear();
 136
 137         saveConfiguration( archivaConfiguration );
 138
 139         CacheManager.getInstance().clearAll();
 140
 141         applicationContext.getBean( MavenIndexerCleaner.class ).cleanupIndex();
 142
 143
 144     }
 145
 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.class.cast( 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         Tomcat.addServlet( context, "repository", new UnauthenticatedRepositoryServlet() );
 166         context.addServletMapping( "/repository/*", "repository" );
 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 Servlet findServlet( String name )
 177         throws Exception
 178     {
 179         Container[] childs = context.findChildren();
 180         for ( Container container : childs )
 181         {
 182             if ( StringUtils.equals( container.getName(), name ) )
 183             {
 184                 Tomcat.ExistingStandardWrapper esw = Tomcat.ExistingStandardWrapper.class.cast( container );
 185                 Servlet servlet = esw.loadServlet();
 186
 187                 return servlet;
 188             }
 189         }
 190         return null;
 191     }
 192
 193     protected String getSpringConfigLocation()
 194     {
 195         return "classpath*:/META-INF/spring-context.xml,classpath*:spring-context.xml";
 196     }
 197
 198
 199
 200
 201     /*
 202     protected ServletUnitClient getServletUnitClient()
 203         throws Exception
 204     {
 205         if ( servletUnitClient != null )
 206         {
 207             return servletUnitClient;
 208         }
 209         servletRunner = new ServletRunner( new File( "src/test/resources/WEB-INF/web.xml" ) );
 210
 211         servletRunner.registerServlet( "/repository/*", UnauthenticatedRepositoryServlet.class.getName() );
 212
 213         servletUnitClient = servletRunner.newClient();
 214
 215         return servletUnitClient;
 216     }*/
 217
 218     /*
 219     protected <P extends Page> P page(final String path) throws IOException {
 220         return newClient().getPage(base.toExternalForm() + "repository/" + path);
 221     }
 222     */
 223
 224     protected static WebClient newClient()
 225     {
 226         final WebClient webClient = new WebClient();
 227         webClient.getOptions().setJavaScriptEnabled( false );
 228         webClient.getOptions().setCssEnabled( false );
 229         webClient.getOptions().setAppletEnabled( false );
 230         webClient.getOptions().setThrowExceptionOnFailingStatusCode( false );
 231         webClient.setAjaxController( new NicelyResynchronizingAjaxController() );
 232         return webClient;
 233     }
 234
 235
 236     protected static WebResponse getWebResponse( String path )
 237         throws Exception
 238     {
 239         WebClient client = newClient();
 240         client.getPage( "http://localhost:" + port + "/reinit/reload" );
 241         return client.getPage( "http://localhost:" + port + path ).getWebResponse();
 242     }
 243
 244     public static class GetMethodWebRequest
 245         extends WebRequest
 246     {
 247         String url;
 248
 249         public GetMethodWebRequest( String url )
 250             throws Exception
 251         {
 252             super( new URL( url ) );
 253             this.url = url;
 254
 255         }
 256     }
 257
 258     public static class PutMethodWebRequest
 259         extends WebRequest
 260     {
 261         String url;
 262
 263         public PutMethodWebRequest( String url, InputStream inputStream, String contentType )
 264             throws Exception
 265         {
 266             super( new URL( url ), HttpMethod.PUT );
 267             this.url = url;
 268
 269         }
 270
 271
 272     }
 273
 274     public static class ServletUnitClient
 275     {
 276
 277         public ServletUnitClient()
 278         {
 279
 280         }
 281
 282         public WebResponse getResponse( WebRequest request )
 283             throws Exception
 284         {
 285             return getWebResponse( request.getUrl().getPath() );
 286         }
 287
 288         public WebResponse getResource( WebRequest request )
 289             throws Exception
 290         {
 291             return getResponse( request );
 292         }
 293     }
 294
 295     public ServletUnitClient getServletUnitClient()
 296     {
 297         return new ServletUnitClient();
 298     }
 299
 300     @Override
 301     @After
 302     public void tearDown()
 303         throws Exception
 304     {
 305
 306         if ( repoRootInternal.exists() )
 307         {
 308             FileUtils.deleteDirectory( repoRootInternal );
 309         }
 310
 311         if ( repoRootLegacy.exists() )
 312         {
 313             FileUtils.deleteDirectory( repoRootLegacy );
 314         }
 315
 316         if ( this.tomcat != null )
 317         {
 318             this.tomcat.stop();
 319         }
 320
 321     }
 322
 323
 324     protected void assertFileContents( String expectedContents, File repoRoot, String path )
 325         throws IOException
 326     {
 327         File actualFile = new File( repoRoot, path );
 328         assertTrue( "File <" + actualFile.getAbsolutePath() + "> should exist.", actualFile.exists() );
 329         assertTrue( "File <" + actualFile.getAbsolutePath() + "> should be a file (not a dir/link/device/etc).",
 330                     actualFile.isFile() );
 331
 332         String actualContents = FileUtils.readFileToString( actualFile, Charset.defaultCharset() );
 333         assertEquals( "File Contents of <" + actualFile.getAbsolutePath() + ">", expectedContents, actualContents );
 334     }
 335
 336     protected void assertRepositoryValid( RepositoryServlet servlet, String repoId )
 337         throws Exception
 338     {
 339         ManagedRepository repository = servlet.getRepository( repoId );
 340         assertNotNull( "Archiva Managed Repository id:<" + repoId + "> should exist.", repository );
 341         File repoRoot = new File( repository.getLocation() );
 342         assertTrue( "Archiva Managed Repository id:<" + repoId + "> should have a valid location on disk.",
 343                     repoRoot.exists() && repoRoot.isDirectory() );
 344     }
 345
 346     protected void assertResponseOK( WebResponse response )
 347     {
 348
 349         assertNotNull( "Should have recieved a response", response );
 350         Assert.assertEquals( "Should have been an OK response code", HttpServletResponse.SC_OK,
 351                              response.getStatusCode() );
 352     }
 353
 354     protected void assertResponseOK( WebResponse response, String path )
 355     {
 356         assertNotNull( "Should have recieved a response", response );
 357         Assert.assertEquals( "Should have been an OK response code for path: " + path, HttpServletResponse.SC_OK,
 358                              response.getStatusCode() );
 359     }
 360
 361     protected void assertResponseNotFound( WebResponse response )
 362     {
 363         assertNotNull( "Should have recieved a response", response );
 364         Assert.assertEquals( "Should have been an 404/Not Found response code.", HttpServletResponse.SC_NOT_FOUND,
 365                              response.getStatusCode() );
 366     }
 367
 368     protected void assertResponseInternalServerError( WebResponse response )
 369     {
 370         assertNotNull( "Should have recieved a response", response );
 371         Assert.assertEquals( "Should have been an 500/Internal Server Error response code.",
 372                              HttpServletResponse.SC_INTERNAL_SERVER_ERROR, response.getStatusCode() );
 373     }
 374
 375     protected void assertResponseConflictError( WebResponse response )
 376     {
 377         assertNotNull( "Should have received a response", response );
 378         Assert.assertEquals( "Should have been a 409/Conflict response code.", HttpServletResponse.SC_CONFLICT,
 379                              response.getStatusCode() );
 380     }
 381
 382     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, File location,
 383                                                                       boolean blockRedeployments )
 384     {
 385         ManagedRepositoryConfiguration repo = new ManagedRepositoryConfiguration();
 386         repo.setId( id );
 387         repo.setName( name );
 388         repo.setLocation( location.getAbsolutePath() );
 389         repo.setBlockRedeployments( blockRedeployments );
 390
 391         return repo;
 392     }
 393
 394     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, File location,
 395                                                                       String layout, boolean blockRedeployments )
 396     {
 397         ManagedRepositoryConfiguration repo = createManagedRepository( id, name, location, blockRedeployments );
 398         repo.setLayout( layout );
 399         return repo;
 400     }
 401
 402     protected RemoteRepositoryConfiguration createRemoteRepository( String id, String name, String url )
 403     {
 404         RemoteRepositoryConfiguration repo = new RemoteRepositoryConfiguration();
 405         repo.setId( id );
 406         repo.setName( name );
 407         repo.setUrl( url );
 408         return repo;
 409     }
 410
 411     protected void saveConfiguration( ArchivaConfiguration archivaConfiguration )
 412         throws Exception
 413     {
 414         archivaConfiguration.save( archivaConfiguration.getConfiguration() );
 415     }
 416
 417
 418     protected void setupCleanRepo( File repoRootDir )
 419         throws IOException
 420     {
 421         FileUtils.deleteDirectory( repoRootDir );
 422         if ( !repoRootDir.exists() )
 423         {
 424             repoRootDir.mkdirs();
 425         }
 426     }
 427
 428     protected void assertManagedFileNotExists( File repoRootInternal, String resourcePath )
 429     {
 430         File repoFile = new File( repoRootInternal, resourcePath );
 431         assertFalse( "Managed Repository File <" + repoFile.getAbsolutePath() + "> should not exist.",
 432                      repoFile.exists() );
 433     }
 434
 435     protected void setupCleanInternalRepo()
 436         throws Exception
 437     {
 438         setupCleanRepo( repoRootInternal );
 439     }
 440
 441     protected File populateRepo( File repoRootManaged, String path, String contents )
 442         throws Exception
 443     {
 444         File destFile = new File( repoRootManaged, path );
 445         destFile.getParentFile().mkdirs();
 446         FileUtils.writeStringToFile( destFile, contents, Charset.defaultCharset() );
 447         return destFile;
 448     }
 449 }