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.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.util.MavenIndexerCleaner;
  37 import org.apache.archiva.webdav.util.ReinitServlet;
  38 import org.apache.catalina.Container;
  39 import org.apache.catalina.Context;
  40 import org.apache.catalina.core.StandardContext;
  41 import org.apache.catalina.deploy.ApplicationParameter;
  42 import org.apache.catalina.startup.Tomcat;
  43 import org.apache.commons.io.FileUtils;
  44 import org.apache.commons.lang.StringUtils;
  45 import org.apache.velocity.app.event.ReferenceInsertionEventHandler;
  46 import org.junit.After;
  47 import org.junit.Before;
  48 import org.junit.runner.RunWith;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51 import org.springframework.beans.BeansException;
  52 import org.springframework.beans.factory.BeanFactory;
  53 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
  54 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
  55 import org.springframework.context.ApplicationContext;
  56 import org.springframework.context.ApplicationEvent;
  57 import org.springframework.context.MessageSourceResolvable;
  58 import org.springframework.context.NoSuchMessageException;
  59 import org.springframework.core.env.Environment;
  60 import org.springframework.core.io.Resource;
  61 import org.springframework.mock.web.MockHttpServletRequest;
  62 import org.springframework.mock.web.MockHttpServletResponse;
  63 import org.springframework.mock.web.MockServletConfig;
  64 import org.springframework.mock.web.MockServletContext;
  65 import org.springframework.test.context.ContextConfiguration;
  66 import org.springframework.web.context.ContextLoaderListener;
  67 import org.springframework.web.context.WebApplicationContext;
  68 import org.springframework.web.context.support.GenericWebApplicationContext;
  69 import org.springframework.web.context.support.StaticWebApplicationContext;
  70 import org.springframework.web.context.support.WebApplicationContextUtils;
  71
  72 import javax.inject.Inject;
  73 import javax.servlet.Servlet;
  74 import javax.servlet.ServletContext;
  75 import javax.servlet.http.HttpServletRequest;
  76 import javax.servlet.http.HttpServletResponse;
  77 import java.io.File;
  78 import java.io.IOException;
  79 import java.io.InputStream;
  80 import java.io.UnsupportedEncodingException;
  81 import java.lang.annotation.Annotation;
  82 import java.net.URL;
  83 import java.nio.charset.Charset;
  84 import java.util.Locale;
  85 import java.util.Map;
  86
  87 /**
  88  * AbstractRepositoryServletTestCase
  89  */
  90 @RunWith( ArchivaSpringJUnit4ClassRunner.class )
  91 @ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:spring-context.xml",
  92     "classpath*:/repository-servlet-simple.xml" } )
  93 public abstract class AbstractRepositoryServletTestCase
  94     extends TestCase
  95 {
  96     protected static final String REPOID_INTERNAL = "internal";
  97
  98     protected static final String REPOID_LEGACY = "legacy";
  99
 100     protected File repoRootInternal;
 101
 102     protected File repoRootLegacy;
 103
 104
 105     protected ArchivaConfiguration archivaConfiguration;
 106
 107     @Inject
 108     protected ApplicationContext applicationContext;
 109
 110     protected Logger log = LoggerFactory.getLogger( getClass() );
 111
 112
 113     protected void saveConfiguration()
 114         throws Exception
 115     {
 116         saveConfiguration( archivaConfiguration );
 117     }
 118
 119     protected Tomcat tomcat;
 120
 121     protected static int port;
 122
 123
 124     StandardContext context;
 125
 126     @Before
 127     public void setUp()
 128         throws Exception
 129     {
 130
 131         super.setUp();
 132
 133         String appserverBase = new File( "target/appserver-base" ).getAbsolutePath();
 134         System.setProperty( "appserver.base", appserverBase );
 135
 136         File testConf = new File( "src/test/resources/repository-archiva.xml" );
 137         File testConfDest = new File( appserverBase, "conf/archiva.xml" );
 138         if ( testConfDest.exists() )
 139         {
 140             FileUtils.deleteQuietly( testConfDest );
 141         }
 142         FileUtils.copyFile( testConf, testConfDest );
 143
 144         archivaConfiguration = applicationContext.getBean( ArchivaConfiguration.class );
 145
 146         repoRootInternal = new File( appserverBase, "data/repositories/internal" );
 147         repoRootLegacy = new File( appserverBase, "data/repositories/legacy" );
 148         Configuration config = archivaConfiguration.getConfiguration();
 149
 150         config.getManagedRepositories().clear();
 151
 152         config.addManagedRepository(
 153             createManagedRepository( REPOID_INTERNAL, "Internal Test Repo", repoRootInternal, true ) );
 154
 155         config.addManagedRepository(
 156             createManagedRepository( REPOID_LEGACY, "Legacy Format Test Repo", repoRootLegacy, "legacy", true ) );
 157
 158         config.getProxyConnectors().clear();
 159
 160         config.getRemoteRepositories().clear();
 161
 162         saveConfiguration( archivaConfiguration );
 163
 164         CacheManager.getInstance().clearAll();
 165
 166         applicationContext.getBean( MavenIndexerCleaner.class ).cleanupIndex();
 167
 168
 169     }
 170
 171     protected UnauthenticatedRepositoryServlet unauthenticatedRepositoryServlet =
 172         new UnauthenticatedRepositoryServlet();
 173
 174     protected void startRepository()
 175         throws Exception
 176     {
 177         /*
 178         tomcat = new Tomcat();
 179         tomcat.setBaseDir( System.getProperty( "java.io.tmpdir" ) );
 180         tomcat.setPort( 0 );
 181
 182         context = StandardContext.class.cast( tomcat.addContext( "", System.getProperty( "java.io.tmpdir" ) ) );
 183
 184         ApplicationParameter applicationParameter = new ApplicationParameter();
 185         applicationParameter.setName( "contextConfigLocation" );
 186         applicationParameter.setValue( getSpringConfigLocation() );
 187         context.addApplicationParameter( applicationParameter );
 188
 189         context.addApplicationListener( ContextLoaderListener.class.getName() );
 190
 191         context.addApplicationListener( MavenIndexerCleaner.class.getName() );
 192
 193         Tomcat.addServlet( context, "repository", new UnauthenticatedRepositoryServlet() );
 194         context.addServletMapping( "/repository/*", "repository" );
 195
 196         Tomcat.addServlet( context, "reinitservlet", new ReinitServlet() );
 197         context.addServletMapping( "/reinit/*", "reinitservlet" );
 198
 199         tomcat.start();
 200
 201         this.port = tomcat.getConnector().getLocalPort();
 202         */
 203
 204         final MockServletContext mockServletContext = new MockServletContext();
 205
 206         WebApplicationContext webApplicationContext =
 207             new TestWebapplicationContext( applicationContext, mockServletContext );
 208
 209         mockServletContext.setAttribute( WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,
 210                                          webApplicationContext );
 211
 212         MockServletConfig mockServletConfig = new MockServletConfig()
 213         {
 214             @Override
 215             public ServletContext getServletContext()
 216             {
 217                 return mockServletContext;
 218             }
 219         };
 220
 221         unauthenticatedRepositoryServlet.init( mockServletConfig );
 222
 223     }
 224
 225
 226     static class TestWebapplicationContext
 227         implements WebApplicationContext
 228     {
 229         private ApplicationContext applicationContext;
 230
 231         private ServletContext servletContext;
 232
 233         TestWebapplicationContext( ApplicationContext applicationContext, ServletContext servletContext )
 234         {
 235             this.applicationContext = applicationContext;
 236         }
 237
 238         @Override
 239         public ServletContext getServletContext()
 240         {
 241             return servletContext;
 242         }
 243
 244         @Override
 245         public String getId()
 246         {
 247             return applicationContext.getId();
 248         }
 249
 250         @Override
 251         public String getApplicationName()
 252         {
 253             return applicationContext.getApplicationName();
 254         }
 255
 256         @Override
 257         public String getDisplayName()
 258         {
 259             return applicationContext.getDisplayName();
 260         }
 261
 262         @Override
 263         public long getStartupDate()
 264         {
 265             return applicationContext.getStartupDate();
 266         }
 267
 268         @Override
 269         public ApplicationContext getParent()
 270         {
 271             return applicationContext.getParent();
 272         }
 273
 274         @Override
 275         public AutowireCapableBeanFactory getAutowireCapableBeanFactory()
 276             throws IllegalStateException
 277         {
 278             return applicationContext.getAutowireCapableBeanFactory();
 279         }
 280
 281         @Override
 282         public void publishEvent( ApplicationEvent applicationEvent )
 283         {
 284             applicationContext.publishEvent( applicationEvent );
 285         }
 286
 287         @Override
 288         public Environment getEnvironment()
 289         {
 290             return applicationContext.getEnvironment();
 291         }
 292
 293         @Override
 294         public BeanFactory getParentBeanFactory()
 295         {
 296             return applicationContext.getParentBeanFactory();
 297         }
 298
 299         @Override
 300         public boolean containsLocalBean( String s )
 301         {
 302             return applicationContext.containsLocalBean( s );
 303         }
 304
 305         @Override
 306         public boolean containsBeanDefinition( String s )
 307         {
 308             return applicationContext.containsBeanDefinition( s );
 309         }
 310
 311         @Override
 312         public int getBeanDefinitionCount()
 313         {
 314             return applicationContext.getBeanDefinitionCount();
 315         }
 316
 317         @Override
 318         public String[] getBeanDefinitionNames()
 319         {
 320             return applicationContext.getBeanDefinitionNames();
 321         }
 322
 323         @Override
 324         public String[] getBeanNamesForType( Class<?> aClass )
 325         {
 326             return applicationContext.getBeanNamesForType( aClass );
 327         }
 328
 329         @Override
 330         public String[] getBeanNamesForType( Class<?> aClass, boolean b, boolean b2 )
 331         {
 332             return applicationContext.getBeanNamesForType( aClass, b, b2 );
 333         }
 334
 335         @Override
 336         public <T> Map<String, T> getBeansOfType( Class<T> tClass )
 337             throws BeansException
 338         {
 339             return applicationContext.getBeansOfType( tClass );
 340         }
 341
 342         @Override
 343         public <T> Map<String, T> getBeansOfType( Class<T> tClass, boolean b, boolean b2 )
 344             throws BeansException
 345         {
 346             return applicationContext.getBeansOfType( tClass, b, b2 );
 347         }
 348
 349         @Override
 350         public String[] getBeanNamesForAnnotation( Class<? extends Annotation> aClass )
 351         {
 352             return applicationContext.getBeanNamesForAnnotation( aClass );
 353         }
 354
 355         @Override
 356         public Map<String, Object> getBeansWithAnnotation( Class<? extends Annotation> aClass )
 357             throws BeansException
 358         {
 359             return applicationContext.getBeansWithAnnotation( aClass );
 360         }
 361
 362         @Override
 363         public <A extends Annotation> A findAnnotationOnBean( String s, Class<A> aClass )
 364             throws NoSuchBeanDefinitionException
 365         {
 366             return applicationContext.findAnnotationOnBean( s, aClass );
 367         }
 368
 369         @Override
 370         public Object getBean( String s )
 371             throws BeansException
 372         {
 373             return applicationContext.getBean( s );
 374         }
 375
 376         @Override
 377         public <T> T getBean( String s, Class<T> tClass )
 378             throws BeansException
 379         {
 380             return applicationContext.getBean( s, tClass );
 381         }
 382
 383         @Override
 384         public <T> T getBean( Class<T> tClass )
 385             throws BeansException
 386         {
 387             return applicationContext.getBean( tClass );
 388         }
 389
 390         @Override
 391         public Object getBean( String s, Object... objects )
 392             throws BeansException
 393         {
 394             return applicationContext.getBean( s, objects );
 395         }
 396
 397         @Override
 398         public boolean containsBean( String s )
 399         {
 400             return applicationContext.containsBean( s );
 401         }
 402
 403         @Override
 404         public boolean isSingleton( String s )
 405             throws NoSuchBeanDefinitionException
 406         {
 407             return applicationContext.isSingleton( s );
 408         }
 409
 410         @Override
 411         public boolean isPrototype( String s )
 412             throws NoSuchBeanDefinitionException
 413         {
 414             return applicationContext.isPrototype( s );
 415         }
 416
 417         @Override
 418         public boolean isTypeMatch( String s, Class<?> aClass )
 419             throws NoSuchBeanDefinitionException
 420         {
 421             return applicationContext.isTypeMatch( s, aClass );
 422         }
 423
 424         @Override
 425         public Class<?> getType( String s )
 426             throws NoSuchBeanDefinitionException
 427         {
 428             return applicationContext.getType( s );
 429         }
 430
 431         @Override
 432         public String[] getAliases( String s )
 433         {
 434             return applicationContext.getAliases( s );
 435         }
 436
 437         @Override
 438         public String getMessage( String s, Object[] objects, String s2, Locale locale )
 439         {
 440             return applicationContext.getMessage( s, objects, s2, locale );
 441         }
 442
 443         @Override
 444         public String getMessage( String s, Object[] objects, Locale locale )
 445             throws NoSuchMessageException
 446         {
 447             return applicationContext.getMessage( s, objects, locale );
 448         }
 449
 450         @Override
 451         public String getMessage( MessageSourceResolvable messageSourceResolvable, Locale locale )
 452             throws NoSuchMessageException
 453         {
 454             return applicationContext.getMessage( messageSourceResolvable, locale );
 455         }
 456
 457         @Override
 458         public Resource[] getResources( String s )
 459             throws IOException
 460         {
 461             return applicationContext.getResources( s );
 462         }
 463
 464         @Override
 465         public Resource getResource( String s )
 466         {
 467             return applicationContext.getResource( s );
 468         }
 469
 470         @Override
 471         public ClassLoader getClassLoader()
 472         {
 473             return applicationContext.getClassLoader();
 474         }
 475     }
 476
 477     protected Servlet findServlet( String name )
 478         throws Exception
 479     {
 480         return unauthenticatedRepositoryServlet;
 481         /*
 482         Container[] childs = context.findChildren();
 483         for ( Container container : childs )
 484         {
 485             if ( StringUtils.equals( container.getName(), name ) )
 486             {
 487                 Tomcat.ExistingStandardWrapper esw = Tomcat.ExistingStandardWrapper.class.cast( container );
 488                 Servlet servlet = esw.loadServlet();
 489
 490                 return servlet;
 491             }
 492         }
 493         return null;*/
 494     }
 495
 496     protected String getSpringConfigLocation()
 497     {
 498         return "classpath*:/META-INF/spring-context.xml,classpath*:spring-context.xml";
 499     }
 500
 501
 502
 503
 504     /*
 505     protected ServletUnitClient getServletUnitClient()
 506         throws Exception
 507     {
 508         if ( servletUnitClient != null )
 509         {
 510             return servletUnitClient;
 511         }
 512         servletRunner = new ServletRunner( new File( "src/test/resources/WEB-INF/web.xml" ) );
 513
 514         servletRunner.registerServlet( "/repository/*", UnauthenticatedRepositoryServlet.class.getName() );
 515
 516         servletUnitClient = servletRunner.newClient();
 517
 518         return servletUnitClient;
 519     }*/
 520
 521     /*
 522     protected <P extends Page> P page(final String path) throws IOException {
 523         return newClient().getPage(base.toExternalForm() + "repository/" + path);
 524     }
 525     */
 526
 527     protected static WebClient newClient()
 528     {
 529         final WebClient webClient = new WebClient();
 530         webClient.getOptions().setJavaScriptEnabled( false );
 531         webClient.getOptions().setCssEnabled( false );
 532         webClient.getOptions().setAppletEnabled( false );
 533         webClient.getOptions().setThrowExceptionOnFailingStatusCode( false );
 534         webClient.setAjaxController( new NicelyResynchronizingAjaxController() );
 535         return webClient;
 536     }
 537
 538
 539     protected WebResponse getWebResponse( String path )
 540         throws Exception
 541     {
 542         return getWebResponse( new GetMethodWebRequest( "http://localhost" + path ) );
 543     }
 544
 545     protected WebResponse getWebResponse( WebRequest webRequest )
 546         throws Exception
 547     {
 548
 549         //WebClient client = newClient();
 550         //client.getPage( "http://localhost:" + port + "/reinit/reload" );
 551         //return client.getPage( "http://localhost:" + port + path ).getWebResponse();
 552
 553         MockHttpServletRequest request = new MockHttpServletRequest();
 554         request.setRequestURI( webRequest.getUrl().getPath() );
 555         request.addHeader( "User-Agent", "Apache Archiva unit test" );
 556
 557         request.setMethod( webRequest.getHttpMethod().name() );
 558
 559         /*
 560         if (webRequest.getHttpMethod() == HttpMethod.PUT)
 561         {
 562             request.set
 563         } */
 564
 565         final MockHttpServletResponse response = execute( request );
 566         return new WebResponse( null, null, 1 )
 567         {
 568             @Override
 569             public String getContentAsString()
 570             {
 571                 try
 572                 {
 573                     return response.getContentAsString();
 574                 }
 575                 catch ( UnsupportedEncodingException e )
 576                 {
 577                     throw new RuntimeException( e.getMessage(), e );
 578                 }
 579             }
 580
 581             @Override
 582             public int getStatusCode()
 583             {
 584                 return response.getStatus();
 585             }
 586         };
 587     }
 588
 589     protected MockHttpServletResponse execute( HttpServletRequest request )
 590         throws Exception
 591     {
 592         MockHttpServletResponse response = new MockHttpServletResponse()
 593         {
 594             public String getContentAsString()
 595                 throws UnsupportedEncodingException
 596             {
 597                 String errorMessage = getErrorMessage();
 598                 return ( errorMessage != null ) ? errorMessage : super.getContentAsString();
 599             }
 600         };
 601         this.unauthenticatedRepositoryServlet.service( request, response );
 602         return response;
 603     }
 604
 605     public static class GetMethodWebRequest
 606         extends WebRequest
 607     {
 608         String url;
 609
 610         public GetMethodWebRequest( String url )
 611             throws Exception
 612         {
 613             super( new URL( url ) );
 614             this.url = url;
 615
 616         }
 617     }
 618
 619     public static class PutMethodWebRequest
 620         extends WebRequest
 621     {
 622         String url;
 623
 624         public PutMethodWebRequest( String url, InputStream inputStream, String contentType )
 625             throws Exception
 626         {
 627             super( new URL( url ), HttpMethod.PUT );
 628             this.url = url;
 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 abstractRepositoryServletTestCase.getWebResponse( request );
 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 }