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