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