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