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.meterware.httpunit.HttpUnitOptions;
  23 import com.meterware.httpunit.WebResponse;
  24 import com.meterware.servletunit.ServletRunner;
  25 import com.meterware.servletunit.ServletUnitClient;
  26 import junit.framework.Assert;
  27 import junit.framework.TestCase;
  28 import net.sf.ehcache.CacheManager;
  29 import org.apache.archiva.admin.model.beans.ManagedRepository;
  30 import org.apache.archiva.configuration.ArchivaConfiguration;
  31 import org.apache.archiva.configuration.Configuration;
  32 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  33 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  34 import org.apache.archiva.webdav.util.MavenIndexerCleaner;
  35 import org.apache.commons.io.FileUtils;
  36 import org.apache.lucene.store.Lock;
  37 import org.apache.lucene.store.LockReleaseFailedException;
  38 import org.apache.lucene.store.NativeFSLockFactory;
  39 import org.junit.After;
  40 import org.junit.Before;
  41 import org.junit.BeforeClass;
  42 import org.junit.runner.RunWith;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45 import org.springframework.context.ApplicationContext;
  46 import org.springframework.test.context.ContextConfiguration;
  47 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  48
  49 import javax.inject.Inject;
  50 import javax.servlet.http.HttpServletResponse;
  51 import java.io.File;
  52 import java.io.IOException;
  53 import java.lang.reflect.Field;
  54 import java.lang.reflect.Method;
  55
  56 /**
  57  * AbstractRepositoryServletTestCase
  58  *
  59  * @version $Id$
  60  */
  61 @RunWith( SpringJUnit4ClassRunner.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 ServletUnitClient sc;
  71
  72     protected File repoRootInternal;
  73
  74     protected File repoRootLegacy;
  75
  76     private ServletRunner sr;
  77
  78     protected ArchivaConfiguration archivaConfiguration;
  79
  80     @Inject
  81     protected ApplicationContext applicationContext;
  82
  83     protected Logger log = LoggerFactory.getLogger( getClass() );
  84
  85
  86     protected void saveConfiguration()
  87         throws Exception
  88     {
  89         saveConfiguration( archivaConfiguration );
  90     }
  91
  92     @BeforeClass
  93     public static void lockCleanup()
  94         throws Exception
  95     {
  96         /*
  97
  98         try
  99         {
 100
 101             /*
 102             Field locks = NativeFSLockFactory.class.getDeclaredClasses()[0].getField( "LOCK_HELD" );
 103             locks.setAccessible( true );
 104             Method clear = locks.getClass().getMethod( "clear" );
 105
 106             clear.invoke( field, null );
 107             */
 108
 109         /*
 110             NativeFSLockFactory nativeFSLockFactory =
 111                 new NativeFSLockFactory( new File( "target/appserver-base/data/repositories/internal/.indexer" ) );
 112
 113             Lock lock = nativeFSLockFactory.makeLock( "write.lock" );
 114             lock.release();
 115             LoggerFactory.getLogger( AbstractRepositoryServletTestCase.class ).info( "cleanup lock" );
 116
 117
 118         }
 119         catch ( LockReleaseFailedException e )
 120         {
 121             // ignore
 122         }
 123         */
 124     }
 125
 126
 127     @Before
 128     public void setUp()
 129         throws Exception
 130     {
 131
 132         lockCleanup();
 133         super.setUp();
 134
 135         String appserverBase = new File( "target/appserver-base" ).getAbsolutePath();
 136         System.setProperty( "appserver.base", appserverBase );
 137
 138         File testConf = new File( "src/test/resources/repository-archiva.xml" );
 139         File testConfDest = new File( appserverBase, "conf/archiva.xml" );
 140         if ( testConfDest.exists() )
 141         {
 142             FileUtils.deleteQuietly( testConfDest );
 143         }
 144         FileUtils.copyFile( testConf, testConfDest );
 145
 146         archivaConfiguration = applicationContext.getBean( ArchivaConfiguration.class );
 147
 148         repoRootInternal = new File( appserverBase, "data/repositories/internal" );
 149         repoRootLegacy = new File( appserverBase, "data/repositories/legacy" );
 150         Configuration config = archivaConfiguration.getConfiguration();
 151
 152         config.getManagedRepositories().clear();
 153
 154         config.addManagedRepository(
 155             createManagedRepository( REPOID_INTERNAL, "Internal Test Repo", repoRootInternal, true ) );
 156
 157         config.addManagedRepository(
 158             createManagedRepository( REPOID_LEGACY, "Legacy Format Test Repo", repoRootLegacy, "legacy", true ) );
 159
 160         config.getProxyConnectors().clear();
 161
 162         config.getRemoteRepositories().clear();
 163
 164         saveConfiguration( archivaConfiguration );
 165
 166         CacheManager.getInstance().clearAll();
 167
 168         HttpUnitOptions.setExceptionsThrownOnErrorStatus( false );
 169
 170         applicationContext.getBean( MavenIndexerCleaner.class ).cleanupIndex();
 171
 172         sr = new ServletRunner( new File( "src/test/resources/WEB-INF/web.xml" ) );
 173
 174         sr.registerServlet( "/repository/*", UnauthenticatedRepositoryServlet.class.getName() );
 175         sc = sr.newClient();
 176     }
 177
 178     @Override
 179     @After
 180     public void tearDown()
 181         throws Exception
 182     {
 183
 184         if ( sc != null )
 185         {
 186             sc.clearContents();
 187         }
 188
 189         if ( sr != null )
 190         {
 191             sr.shutDown();
 192         }
 193
 194         if ( repoRootInternal.exists() )
 195         {
 196             FileUtils.deleteDirectory( repoRootInternal );
 197         }
 198
 199         if ( repoRootLegacy.exists() )
 200         {
 201             FileUtils.deleteDirectory( repoRootLegacy );
 202         }
 203
 204         super.tearDown();
 205     }
 206
 207
 208     protected void assertFileContents( String expectedContents, File repoRoot, String path )
 209         throws IOException
 210     {
 211         File actualFile = new File( repoRoot, path );
 212         assertTrue( "File <" + actualFile.getAbsolutePath() + "> should exist.", actualFile.exists() );
 213         assertTrue( "File <" + actualFile.getAbsolutePath() + "> should be a file (not a dir/link/device/etc).",
 214                     actualFile.isFile() );
 215
 216         String actualContents = FileUtils.readFileToString( actualFile, null );
 217         assertEquals( "File Contents of <" + actualFile.getAbsolutePath() + ">", expectedContents, actualContents );
 218     }
 219
 220     protected void assertRepositoryValid( RepositoryServlet servlet, String repoId )
 221         throws Exception
 222     {
 223         ManagedRepository repository = servlet.getRepository( repoId );
 224         assertNotNull( "Archiva Managed Repository id:<" + repoId + "> should exist.", repository );
 225         File repoRoot = new File( repository.getLocation() );
 226         assertTrue( "Archiva Managed Repository id:<" + repoId + "> should have a valid location on disk.",
 227                     repoRoot.exists() && repoRoot.isDirectory() );
 228     }
 229
 230     protected void assertResponseOK( WebResponse response )
 231     {
 232         assertNotNull( "Should have recieved a response", response );
 233         Assert.assertEquals( "Should have been an OK response code", HttpServletResponse.SC_OK,
 234                              response.getResponseCode() );
 235     }
 236
 237     protected void assertResponseOK( WebResponse response, String path )
 238     {
 239         assertNotNull( "Should have recieved a response", response );
 240         Assert.assertEquals( "Should have been an OK response code for path: " + path, HttpServletResponse.SC_OK,
 241                              response.getResponseCode() );
 242     }
 243
 244     protected void assertResponseNotFound( WebResponse response )
 245     {
 246         assertNotNull( "Should have recieved a response", response );
 247         Assert.assertEquals( "Should have been an 404/Not Found response code.", HttpServletResponse.SC_NOT_FOUND,
 248                              response.getResponseCode() );
 249     }
 250
 251     protected void assertResponseInternalServerError( WebResponse response )
 252     {
 253         assertNotNull( "Should have recieved a response", response );
 254         Assert.assertEquals( "Should have been an 500/Internal Server Error response code.",
 255                              HttpServletResponse.SC_INTERNAL_SERVER_ERROR, response.getResponseCode() );
 256     }
 257
 258     protected void assertResponseConflictError( WebResponse response )
 259     {
 260         assertNotNull( "Should have received a response", response );
 261         Assert.assertEquals( "Should have been a 409/Conflict response code.", HttpServletResponse.SC_CONFLICT,
 262                              response.getResponseCode() );
 263     }
 264
 265     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, File location,
 266                                                                       boolean blockRedeployments )
 267     {
 268         ManagedRepositoryConfiguration repo = new ManagedRepositoryConfiguration();
 269         repo.setId( id );
 270         repo.setName( name );
 271         repo.setLocation( location.getAbsolutePath() );
 272         repo.setBlockRedeployments( blockRedeployments );
 273
 274         return repo;
 275     }
 276
 277     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, File location,
 278                                                                       String layout, boolean blockRedeployments )
 279     {
 280         ManagedRepositoryConfiguration repo = createManagedRepository( id, name, location, blockRedeployments );
 281         repo.setLayout( layout );
 282         return repo;
 283     }
 284
 285     protected RemoteRepositoryConfiguration createRemoteRepository( String id, String name, String url )
 286     {
 287         RemoteRepositoryConfiguration repo = new RemoteRepositoryConfiguration();
 288         repo.setId( id );
 289         repo.setName( name );
 290         repo.setUrl( url );
 291         return repo;
 292     }
 293
 294     protected void saveConfiguration( ArchivaConfiguration archivaConfiguration )
 295         throws Exception
 296     {
 297         archivaConfiguration.save( archivaConfiguration.getConfiguration() );
 298     }
 299
 300
 301     protected void setupCleanRepo( File repoRootDir )
 302         throws IOException
 303     {
 304         FileUtils.deleteDirectory( repoRootDir );
 305         if ( !repoRootDir.exists() )
 306         {
 307             repoRootDir.mkdirs();
 308         }
 309     }
 310
 311     protected void assertManagedFileNotExists( File repoRootInternal, String resourcePath )
 312     {
 313         File repoFile = new File( repoRootInternal, resourcePath );
 314         assertFalse( "Managed Repository File <" + repoFile.getAbsolutePath() + "> should not exist.",
 315                      repoFile.exists() );
 316     }
 317
 318     protected void setupCleanInternalRepo()
 319         throws Exception
 320     {
 321         setupCleanRepo( repoRootInternal );
 322     }
 323
 324     protected File populateRepo( File repoRootManaged, String path, String contents )
 325         throws Exception
 326     {
 327         File destFile = new File( repoRootManaged, path );
 328         destFile.getParentFile().mkdirs();
 329         FileUtils.writeStringToFile( destFile, contents, null );
 330         return destFile;
 331     }
 332 }