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.*;
  23 import junit.framework.TestCase;
  24 import net.sf.ehcache.CacheManager;
  25 import org.apache.archiva.admin.model.beans.ManagedRepository;
  26 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  27 import org.apache.archiva.configuration.ArchivaConfiguration;
  28 import org.apache.archiva.configuration.Configuration;
  29 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  30 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  31 import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
  32 import org.apache.archiva.webdav.httpunit.MkColMethodWebRequest;
  33 import org.apache.archiva.webdav.util.MavenIndexerCleaner;
  34 import org.apache.commons.io.FileUtils;
  35 import org.apache.commons.io.IOUtils;
  36 import org.apache.commons.lang.StringUtils;
  37 import org.junit.After;
  38 import org.junit.Assert;
  39 import org.junit.Before;
  40 import org.junit.runner.RunWith;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43 import org.springframework.beans.BeansException;
  44 import org.springframework.beans.factory.BeanFactory;
  45 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
  46 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
  47 import org.springframework.context.ApplicationContext;
  48 import org.springframework.context.ApplicationEvent;
  49 import org.springframework.context.MessageSourceResolvable;
  50 import org.springframework.context.NoSuchMessageException;
  51 import org.springframework.core.ResolvableType;
  52 import org.springframework.core.env.Environment;
  53 import org.springframework.core.io.Resource;
  54 import org.springframework.mock.web.MockHttpServletRequest;
  55 import org.springframework.mock.web.MockHttpServletResponse;
  56 import org.springframework.mock.web.MockServletConfig;
  57 import org.springframework.mock.web.MockServletContext;
  58 import org.springframework.test.context.ContextConfiguration;
  59 import org.springframework.web.context.WebApplicationContext;
  60
  61 import javax.inject.Inject;
  62 import javax.servlet.Servlet;
  63 import javax.servlet.ServletContext;
  64 import javax.servlet.http.HttpServletRequest;
  65 import javax.servlet.http.HttpServletResponse;
  66 import java.io.IOException;
  67 import java.io.InputStream;
  68 import java.io.UnsupportedEncodingException;
  69 import java.lang.annotation.Annotation;
  70 import java.net.URL;
  71 import java.nio.charset.Charset;
  72 import java.nio.file.Files;
  73 import java.nio.file.Path;
  74 import java.nio.file.Paths;
  75 import java.util.Locale;
  76 import java.util.Map;
  77
  78 /**
  79  * AbstractRepositoryServletTestCase
  80  */
  81 @RunWith( ArchivaSpringJUnit4ClassRunner.class )
  82 @ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:spring-context.xml",
  83     "classpath*:/repository-servlet-simple.xml" } )
  84 public abstract class AbstractRepositoryServletTestCase
  85     extends TestCase
  86 {
  87     protected static final String REPOID_INTERNAL = "internal";
  88
  89     protected Path repoRootInternal;
  90
  91     protected Path repoRootLegacy;
  92
  93     @Inject
  94     protected ArchivaConfiguration archivaConfiguration;
  95
  96     @Inject
  97     protected ApplicationContext applicationContext;
  98
  99     @Inject
 100     protected ManagedRepositoryAdmin managedRepositoryAdmin;
 101
 102     protected Logger log = LoggerFactory.getLogger( getClass() );
 103
 104
 105     protected void saveConfiguration()
 106         throws Exception
 107     {
 108         saveConfiguration( archivaConfiguration );
 109     }
 110
 111     @Before
 112     @Override
 113     public void setUp()
 114         throws Exception
 115     {
 116
 117         super.setUp();
 118
 119         String appserverBase = Paths.get( "target/appserver-base" ).toAbsolutePath().toString();
 120         System.setProperty( "appserver.base", appserverBase );
 121
 122         Path testConf = Paths.get( "src/test/resources/repository-archiva.xml" );
 123         Path testConfDest = Paths.get(appserverBase, "conf/archiva.xml" );
 124         if ( Files.exists(testConfDest) )
 125         {
 126             org.apache.archiva.common.utils.FileUtils.deleteQuietly( testConfDest );
 127         }
 128         FileUtils.copyFile( testConf.toFile(), testConfDest.toFile() );
 129
 130         repoRootInternal = Paths.get( appserverBase, "data/repositories/internal" );
 131         repoRootLegacy = Paths.get( appserverBase, "data/repositories/legacy" );
 132         Configuration config = archivaConfiguration.getConfiguration();
 133
 134         config.getManagedRepositories().clear();
 135
 136         config.addManagedRepository(
 137             createManagedRepository( REPOID_INTERNAL, "Internal Test Repo", repoRootInternal, true ) );
 138
 139         managedRepositoryAdmin.createIndexContext( managedRepositoryAdmin.getManagedRepository( REPOID_INTERNAL ) );
 140
 141         config.getProxyConnectors().clear();
 142
 143         config.getRemoteRepositories().clear();
 144
 145         saveConfiguration( archivaConfiguration );
 146
 147         CacheManager.getInstance().clearAll();
 148
 149         applicationContext.getBean( MavenIndexerCleaner.class ).cleanupIndex();
 150
 151
 152     }
 153
 154     protected UnauthenticatedRepositoryServlet unauthenticatedRepositoryServlet =
 155         new UnauthenticatedRepositoryServlet();
 156
 157     protected void startRepository()
 158         throws Exception
 159     {
 160
 161         final MockServletContext mockServletContext = new MockServletContext();
 162
 163         WebApplicationContext webApplicationContext =
 164             new TestWebapplicationContext( applicationContext, mockServletContext );
 165
 166         mockServletContext.setAttribute( WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,
 167                                          webApplicationContext );
 168
 169         MockServletConfig mockServletConfig = new MockServletConfig()
 170         {
 171             @Override
 172             public ServletContext getServletContext()
 173             {
 174                 return mockServletContext;
 175             }
 176         };
 177
 178         unauthenticatedRepositoryServlet.init( mockServletConfig );
 179
 180     }
 181
 182     protected String createVersionMetadata(String groupId, String artifactId, String version) {
 183         return createVersionMetadata(groupId, artifactId, version, null, null, null);
 184     }
 185
 186     protected String createVersionMetadata(String groupId, String artifactId, String version, String timestamp, String buildNumber, String lastUpdated) {
 187         StringBuilder buf = new StringBuilder();
 188         buf.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n");
 189         buf.append("<metadata>\n");
 190         buf.append("  <groupId>").append(groupId).append("</groupId>\n");
 191         buf.append("  <artifactId>").append(artifactId).append("</artifactId>\n");
 192         buf.append("  <version>").append(version).append("</version>\n");
 193         boolean hasSnapshot = StringUtils.isNotBlank(timestamp) || StringUtils.isNotBlank(buildNumber);
 194         boolean hasLastUpdated = StringUtils.isNotBlank(lastUpdated);
 195         if (hasSnapshot || hasLastUpdated) {
 196             buf.append("  <versioning>\n");
 197             if (hasSnapshot) {
 198                 buf.append("    <snapshot>\n");
 199                 buf.append("      <buildNumber>").append(buildNumber).append("</buildNumber>\n");
 200                 buf.append("      <timestamp>").append(timestamp).append("</timestamp>\n");
 201                 buf.append("    </snapshot>\n");
 202             }
 203             if (hasLastUpdated) {
 204                 buf.append("    <lastUpdated>").append(lastUpdated).append("</lastUpdated>\n");
 205             }
 206             buf.append("  </versioning>\n");
 207         }
 208         buf.append("</metadata>");
 209         return buf.toString();
 210     }
 211
 212
 213     public static class TestWebapplicationContext
 214         implements WebApplicationContext
 215     {
 216         private ApplicationContext applicationContext;
 217
 218         private ServletContext servletContext;
 219
 220         TestWebapplicationContext( ApplicationContext applicationContext, ServletContext servletContext )
 221         {
 222             this.applicationContext = applicationContext;
 223         }
 224
 225         @Override
 226         public ServletContext getServletContext()
 227         {
 228             return servletContext;
 229         }
 230
 231         @Override
 232         public String getId()
 233         {
 234             return applicationContext.getId();
 235         }
 236
 237         @Override
 238         public String getApplicationName()
 239         {
 240             return applicationContext.getApplicationName();
 241         }
 242
 243         @Override
 244         public String getDisplayName()
 245         {
 246             return applicationContext.getDisplayName();
 247         }
 248
 249         @Override
 250         public long getStartupDate()
 251         {
 252             return applicationContext.getStartupDate();
 253         }
 254
 255         @Override
 256         public ApplicationContext getParent()
 257         {
 258             return applicationContext.getParent();
 259         }
 260
 261         @Override
 262         public AutowireCapableBeanFactory getAutowireCapableBeanFactory()
 263             throws IllegalStateException
 264         {
 265             return applicationContext.getAutowireCapableBeanFactory();
 266         }
 267
 268         @Override
 269         public void publishEvent( ApplicationEvent applicationEvent )
 270         {
 271             applicationContext.publishEvent( applicationEvent );
 272         }
 273
 274         @Override
 275         public Environment getEnvironment()
 276         {
 277             return applicationContext.getEnvironment();
 278         }
 279
 280         @Override
 281         public BeanFactory getParentBeanFactory()
 282         {
 283             return applicationContext.getParentBeanFactory();
 284         }
 285
 286         @Override
 287         public boolean containsLocalBean( String s )
 288         {
 289             return applicationContext.containsLocalBean( s );
 290         }
 291
 292         @Override
 293         public boolean containsBeanDefinition( String s )
 294         {
 295             return applicationContext.containsBeanDefinition( s );
 296         }
 297
 298         @Override
 299         public int getBeanDefinitionCount()
 300         {
 301             return applicationContext.getBeanDefinitionCount();
 302         }
 303
 304         @Override
 305         public String[] getBeanDefinitionNames()
 306         {
 307             return applicationContext.getBeanDefinitionNames();
 308         }
 309
 310         @Override
 311         public String[] getBeanNamesForType( Class<?> aClass )
 312         {
 313             return applicationContext.getBeanNamesForType( aClass );
 314         }
 315
 316         @Override
 317         public String[] getBeanNamesForType( Class<?> aClass, boolean b, boolean b2 )
 318         {
 319             return applicationContext.getBeanNamesForType( aClass, b, b2 );
 320         }
 321
 322         @Override
 323         public <T> Map<String, T> getBeansOfType( Class<T> tClass )
 324             throws BeansException
 325         {
 326             return applicationContext.getBeansOfType( tClass );
 327         }
 328
 329         @Override
 330         public <T> Map<String, T> getBeansOfType( Class<T> tClass, boolean b, boolean b2 )
 331             throws BeansException
 332         {
 333             return applicationContext.getBeansOfType( tClass, b, b2 );
 334         }
 335
 336         @Override
 337         public String[] getBeanNamesForAnnotation( Class<? extends Annotation> aClass )
 338         {
 339             return applicationContext.getBeanNamesForAnnotation( aClass );
 340         }
 341
 342         @Override
 343         public Map<String, Object> getBeansWithAnnotation( Class<? extends Annotation> aClass )
 344             throws BeansException
 345         {
 346             return applicationContext.getBeansWithAnnotation( aClass );
 347         }
 348
 349         @Override
 350         public <A extends Annotation> A findAnnotationOnBean( String s, Class<A> aClass )
 351             throws NoSuchBeanDefinitionException
 352         {
 353             return applicationContext.findAnnotationOnBean( s, aClass );
 354         }
 355
 356         @Override
 357         public <T> T getBean( Class<T> aClass, Object... objects )
 358             throws BeansException
 359         {
 360             return applicationContext.getBean( aClass, objects );
 361         }
 362
 363         @Override
 364         public Object getBean( String s )
 365             throws BeansException
 366         {
 367             return applicationContext.getBean( s );
 368         }
 369
 370         @Override
 371         public <T> T getBean( String s, Class<T> tClass )
 372             throws BeansException
 373         {
 374             return applicationContext.getBean( s, tClass );
 375         }
 376
 377         @Override
 378         public <T> T getBean( Class<T> tClass )
 379             throws BeansException
 380         {
 381             return applicationContext.getBean( tClass );
 382         }
 383
 384         @Override
 385         public Object getBean( String s, Object... objects )
 386             throws BeansException
 387         {
 388             return applicationContext.getBean( s, objects );
 389         }
 390
 391         @Override
 392         public boolean containsBean( String s )
 393         {
 394             return applicationContext.containsBean( s );
 395         }
 396
 397         @Override
 398         public boolean isSingleton( String s )
 399             throws NoSuchBeanDefinitionException
 400         {
 401             return applicationContext.isSingleton( s );
 402         }
 403
 404         @Override
 405         public boolean isPrototype( String s )
 406             throws NoSuchBeanDefinitionException
 407         {
 408             return applicationContext.isPrototype( s );
 409         }
 410
 411         @Override
 412         public boolean isTypeMatch( String s, Class<?> aClass )
 413             throws NoSuchBeanDefinitionException
 414         {
 415             return applicationContext.isTypeMatch( s, aClass );
 416         }
 417
 418         @Override
 419         public Class<?> getType( String s )
 420             throws NoSuchBeanDefinitionException
 421         {
 422             return applicationContext.getType( s );
 423         }
 424
 425         @Override
 426         public String[] getAliases( String s )
 427         {
 428             return applicationContext.getAliases( s );
 429         }
 430
 431         @Override
 432         public String getMessage( String s, Object[] objects, String s2, Locale locale )
 433         {
 434             return applicationContext.getMessage( s, objects, s2, locale );
 435         }
 436
 437         @Override
 438         public String getMessage( String s, Object[] objects, Locale locale )
 439             throws NoSuchMessageException
 440         {
 441             return applicationContext.getMessage( s, objects, locale );
 442         }
 443
 444         @Override
 445         public String getMessage( MessageSourceResolvable messageSourceResolvable, Locale locale )
 446             throws NoSuchMessageException
 447         {
 448             return applicationContext.getMessage( messageSourceResolvable, locale );
 449         }
 450
 451         @Override
 452         public Resource[] getResources( String s )
 453             throws IOException
 454         {
 455             return applicationContext.getResources( s );
 456         }
 457
 458         @Override
 459         public void publishEvent( Object o )
 460         {
 461             // no op
 462         }
 463
 464         @Override
 465         public String[] getBeanNamesForType( ResolvableType resolvableType )
 466         {
 467             return new String[0];
 468         }
 469
 470         @Override
 471         public boolean isTypeMatch( String s, ResolvableType resolvableType )
 472             throws NoSuchBeanDefinitionException
 473         {
 474             return false;
 475         }
 476
 477         @Override
 478         public Resource getResource( String s )
 479         {
 480             return applicationContext.getResource( s );
 481         }
 482
 483         @Override
 484         public ClassLoader getClassLoader()
 485         {
 486             return applicationContext.getClassLoader();
 487         }
 488     }
 489
 490     protected Servlet findServlet( String name )
 491         throws Exception
 492     {
 493         return unauthenticatedRepositoryServlet;
 494
 495     }
 496
 497     protected String getSpringConfigLocation()
 498     {
 499         return "classpath*:/META-INF/spring-context.xml,classpath*:spring-context.xml";
 500     }
 501
 502
 503     protected static WebClient newClient()
 504     {
 505         final WebClient webClient = new WebClient();
 506         webClient.getOptions().setJavaScriptEnabled( false );
 507         webClient.getOptions().setCssEnabled( false );
 508         webClient.getOptions().setAppletEnabled( false );
 509         webClient.getOptions().setThrowExceptionOnFailingStatusCode( false );
 510         webClient.setAjaxController( new NicelyResynchronizingAjaxController() );
 511         return webClient;
 512     }
 513
 514
 515     protected WebResponse getWebResponse( String path )
 516         throws Exception
 517     {
 518         return getWebResponse( new GetMethodWebRequest( "http://localhost" + path ) );//, false );
 519     }
 520
 521     protected WebResponse getWebResponse( WebRequest webRequest ) //, boolean followRedirect )
 522         throws Exception
 523     {
 524
 525         MockHttpServletRequest request = new MockHttpServletRequest();
 526         request.setRequestURI( webRequest.getUrl().getPath() );
 527         request.addHeader( "User-Agent", "Apache Archiva unit test" );
 528
 529         request.setMethod( webRequest.getHttpMethod().name() );
 530
 531         if ( webRequest.getHttpMethod() == HttpMethod.PUT )
 532         {
 533             PutMethodWebRequest putRequest = PutMethodWebRequest.class.cast( webRequest );
 534             request.setContentType( putRequest.contentType );
 535             request.setContent( IOUtils.toByteArray( putRequest.inputStream ) );
 536         }
 537
 538         if ( webRequest instanceof MkColMethodWebRequest )
 539         {
 540             request.setMethod( "MKCOL" );
 541         }
 542
 543         final MockHttpServletResponse response = execute( request );
 544
 545         if ( response.getStatus() == HttpServletResponse.SC_MOVED_PERMANENTLY
 546             || response.getStatus() == HttpServletResponse.SC_MOVED_TEMPORARILY )
 547         {
 548             String location = response.getHeader( "Location" );
 549             log.debug( "follow redirect to {}", location );
 550             return getWebResponse( new GetMethodWebRequest( location ) );
 551         }
 552
 553         return new WebResponse( null, null, 1 )
 554         {
 555             @Override
 556             public String getContentAsString()
 557             {
 558                 try
 559                 {
 560                     return response.getContentAsString();
 561                 }
 562                 catch ( UnsupportedEncodingException e )
 563                 {
 564                     throw new RuntimeException( e.getMessage(), e );
 565                 }
 566             }
 567
 568             @Override
 569             public int getStatusCode()
 570             {
 571                 return response.getStatus();
 572             }
 573
 574             @Override
 575             public String getResponseHeaderValue( String headerName )
 576             {
 577                 return response.getHeader( headerName );
 578             }
 579         };
 580     }
 581
 582     protected MockHttpServletResponse execute( HttpServletRequest request )
 583         throws Exception
 584     {
 585         MockHttpServletResponse response = new MockHttpServletResponse()
 586         {
 587             @Override
 588             public String getContentAsString()
 589                 throws UnsupportedEncodingException
 590             {
 591                 String errorMessage = getErrorMessage();
 592                 return ( errorMessage != null ) ? errorMessage : super.getContentAsString();
 593             }
 594         };
 595         this.unauthenticatedRepositoryServlet.service( request, response );
 596         return response;
 597     }
 598
 599     public static class GetMethodWebRequest
 600         extends WebRequest
 601     {
 602         String url;
 603
 604         public GetMethodWebRequest( String url )
 605             throws Exception
 606         {
 607             super( new URL( url ) );
 608             this.url = url;
 609
 610         }
 611     }
 612
 613     public static class PutMethodWebRequest
 614         extends WebRequest
 615     {
 616         String url;
 617
 618         InputStream inputStream;
 619
 620         String contentType;
 621
 622         public PutMethodWebRequest( String url, InputStream inputStream, String contentType )
 623             throws Exception
 624         {
 625             super( new URL( url ), HttpMethod.PUT );
 626             this.url = url;
 627             this.inputStream = inputStream;
 628             this.contentType = contentType;
 629         }
 630
 631
 632     }
 633
 634     public static class ServletUnitClient
 635     {
 636
 637         AbstractRepositoryServletTestCase abstractRepositoryServletTestCase;
 638
 639         public ServletUnitClient( AbstractRepositoryServletTestCase abstractRepositoryServletTestCase )
 640         {
 641             this.abstractRepositoryServletTestCase = abstractRepositoryServletTestCase;
 642         }
 643
 644         public WebResponse getResponse( WebRequest request )
 645             throws Exception
 646         {
 647             return getResponse( request, false );
 648         }
 649
 650         public WebResponse getResponse( WebRequest request, boolean followRedirect )
 651             throws Exception
 652         {
 653             // alwasy following redirect as it's normal
 654             return abstractRepositoryServletTestCase.getWebResponse( request );//, followRedirect );
 655         }
 656
 657         public WebResponse getResource( WebRequest request )
 658             throws Exception
 659         {
 660             return getResponse( request );
 661         }
 662     }
 663
 664     public ServletUnitClient getServletUnitClient()
 665     {
 666         return new ServletUnitClient( this );
 667     }
 668
 669     @Override
 670     @After
 671     public void tearDown()
 672         throws Exception
 673     {
 674
 675         if ( Files.exists(repoRootInternal) )
 676         {
 677             org.apache.archiva.common.utils.FileUtils.deleteDirectory( repoRootInternal );
 678         }
 679
 680         if ( Files.exists(repoRootLegacy) )
 681         {
 682             org.apache.archiva.common.utils.FileUtils.deleteDirectory( repoRootLegacy );
 683         }
 684
 685     }
 686
 687
 688     protected void assertFileContents( String expectedContents, Path repoRoot, String subpath )
 689         throws IOException
 690     {
 691         String path = Paths.get(subpath).isAbsolute() ? subpath.substring( 1,subpath.length() ) : subpath;
 692         Path actualFile = repoRoot.resolve( path );
 693         assertTrue( "File <" + actualFile.toAbsolutePath() + "> should exist.", Files.exists(actualFile) );
 694         assertTrue( "File <" + actualFile.toAbsolutePath() + "> should be a file (not a dir/link/device/etc).",
 695                     Files.isRegularFile( actualFile ) );
 696
 697         String actualContents = org.apache.archiva.common.utils.FileUtils.readFileToString( actualFile, Charset.defaultCharset() );
 698         assertEquals( "File Contents of <" + actualFile.toAbsolutePath() + ">", expectedContents, actualContents );
 699     }
 700
 701     protected void assertRepositoryValid( RepositoryServlet servlet, String repoId )
 702         throws Exception
 703     {
 704         ManagedRepository repository = servlet.getRepository( repoId );
 705         assertNotNull( "Archiva Managed Repository id:<" + repoId + "> should exist.", repository );
 706         Path repoRoot = Paths.get( repository.getLocation() );
 707         assertTrue( "Archiva Managed Repository id:<" + repoId + "> should have a valid location on disk.",
 708                     Files.exists(repoRoot) && Files.isDirectory(repoRoot) );
 709     }
 710
 711     protected void assertResponseOK( WebResponse response )
 712     {
 713         assertNotNull( "Should have recieved a response", response );
 714         Assert.assertEquals( "Should have been an OK response code", //
 715                              HttpServletResponse.SC_OK, //
 716                              response.getStatusCode() );
 717     }
 718
 719     protected void assertResponseOK( WebResponse response, String path )
 720     {
 721         assertNotNull( "Should have recieved a response", response );
 722         Assert.assertEquals( "Should have been an OK response code for path: " + path, HttpServletResponse.SC_OK,
 723                              response.getStatusCode() );
 724     }
 725
 726     protected void assertResponseNotFound( WebResponse response )
 727     {
 728         assertNotNull( "Should have recieved a response", response );
 729         Assert.assertEquals( "Should have been an 404/Not Found response code.", HttpServletResponse.SC_NOT_FOUND,
 730                              response.getStatusCode() );
 731     }
 732
 733     protected void assertResponseInternalServerError( WebResponse response )
 734     {
 735         assertNotNull( "Should have recieved a response", response );
 736         Assert.assertEquals( "Should have been an 500/Internal Server Error response code.",
 737                              HttpServletResponse.SC_INTERNAL_SERVER_ERROR, response.getStatusCode() );
 738     }
 739
 740     protected void assertResponseConflictError( WebResponse response )
 741     {
 742         assertNotNull( "Should have received a response", response );
 743         Assert.assertEquals( "Should have been a 409/Conflict response code.", HttpServletResponse.SC_CONFLICT,
 744                              response.getStatusCode() );
 745     }
 746
 747     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, Path location,
 748                                                                       boolean blockRedeployments )
 749     {
 750         ManagedRepositoryConfiguration repo = new ManagedRepositoryConfiguration();
 751         repo.setId( id );
 752         repo.setName( name );
 753         repo.setLocation( location.toAbsolutePath().toString() );
 754         repo.setBlockRedeployments( blockRedeployments );
 755
 756         return repo;
 757     }
 758
 759     protected ManagedRepositoryConfiguration createManagedRepository( String id, String name, Path location,
 760                                                                       String layout, boolean blockRedeployments )
 761     {
 762         ManagedRepositoryConfiguration repo = createManagedRepository( id, name, location, blockRedeployments );
 763         repo.setLayout( layout );
 764         return repo;
 765     }
 766
 767     protected RemoteRepositoryConfiguration createRemoteRepository( String id, String name, String url )
 768     {
 769         RemoteRepositoryConfiguration repo = new RemoteRepositoryConfiguration();
 770         repo.setId( id );
 771         repo.setName( name );
 772         repo.setUrl( url );
 773         return repo;
 774     }
 775
 776     protected void saveConfiguration( ArchivaConfiguration archivaConfiguration )
 777         throws Exception
 778     {
 779         archivaConfiguration.save( archivaConfiguration.getConfiguration() );
 780     }
 781
 782
 783     protected void setupCleanRepo( Path repoRootDir )
 784         throws IOException
 785     {
 786         org.apache.archiva.common.utils.FileUtils.deleteDirectory( repoRootDir );
 787         if ( !Files.exists(repoRootDir) )
 788         {
 789             Files.createDirectories( repoRootDir );
 790         }
 791     }
 792
 793     protected void assertManagedFileNotExists( Path repoRootInternal, String resourcePath )
 794     {
 795         Path repoFile =  repoRootInternal.resolve( resourcePath );
 796         assertFalse( "Managed Repository File <" + repoFile.toAbsolutePath() + "> should not exist.",
 797                      Files.exists(repoFile) );
 798     }
 799
 800     protected void setupCleanInternalRepo()
 801         throws Exception
 802     {
 803         setupCleanRepo( repoRootInternal );
 804     }
 805
 806     protected Path populateRepo( Path repoRootManaged, String path, String contents )
 807         throws Exception
 808     {
 809         Path destFile = repoRootManaged.resolve( path );
 810         Files.createDirectories( destFile.getParent() );
 811         org.apache.archiva.common.utils.FileUtils.writeStringToFile( destFile, Charset.defaultCharset(), contents );
 812         return destFile;
 813     }
 814 }