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