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

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