source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.proxy;
   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 net.sf.ehcache.CacheManager;
  23 import org.apache.archiva.admin.model.beans.ManagedRepository;
  24 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  25 import org.apache.archiva.admin.repository.managed.DefaultManagedRepositoryAdmin;
  26 import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
  27 import org.apache.archiva.configuration.ArchivaConfiguration;
  28 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  29 import org.apache.archiva.configuration.ProxyConnectorConfiguration;
  30 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  31 import org.apache.archiva.policies.CachedFailuresPolicy;
  32 import org.apache.archiva.policies.ChecksumPolicy;
  33 import org.apache.archiva.policies.PropagateErrorsDownloadPolicy;
  34 import org.apache.archiva.policies.PropagateErrorsOnUpdateDownloadPolicy;
  35 import org.apache.archiva.policies.ReleasesPolicy;
  36 import org.apache.archiva.policies.SnapshotsPolicy;
  37 import org.apache.archiva.proxy.model.RepositoryProxyConnectors;
  38 import org.apache.archiva.repository.ManagedRepositoryContent;
  39 import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
  40 import org.apache.commons.io.FileUtils;
  41 import org.apache.maven.index.NexusIndexer;
  42 import org.apache.maven.index.context.IndexingContext;
  43 import org.apache.maven.wagon.Wagon;
  44 import org.easymock.EasyMock;
  45 import org.easymock.IMocksControl;
  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.context.ApplicationContext;
  52 import org.springframework.test.context.ContextConfiguration;
  53
  54 import javax.inject.Inject;
  55 import java.io.BufferedReader;
  56 import java.io.File;
  57 import java.io.FileReader;
  58 import java.io.IOException;
  59 import java.nio.charset.Charset;
  60 import java.text.ParseException;
  61 import java.text.SimpleDateFormat;
  62 import java.util.ArrayList;
  63 import java.util.Calendar;
  64 import java.util.Collection;
  65 import java.util.Date;
  66 import java.util.Locale;
  67
  68 import static org.junit.Assert.*;
  69
  70 /**
  71  * AbstractProxyTestCase
  72  */
  73 @RunWith ( ArchivaSpringJUnit4ClassRunner.class )
  74 @ContextConfiguration ( locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" } )
  75 public abstract class AbstractProxyTestCase
  76 {
  77     @Inject
  78     protected ApplicationContext applicationContext;
  79
  80     protected static final String ID_LEGACY_PROXIED = "legacy-proxied";
  81
  82     protected static final String ID_PROXIED1 = "proxied1";
  83
  84     protected static final String ID_PROXIED1_TARGET = "proxied1-target";
  85
  86     protected static final String ID_PROXIED2 = "proxied2";
  87
  88     protected static final String ID_PROXIED2_TARGET = "proxied2-target";
  89
  90     protected static final String ID_DEFAULT_MANAGED = "default-managed-repository";
  91
  92     protected static final String ID_LEGACY_MANAGED = "legacy-managed-repository";
  93
  94     protected static final String REPOPATH_PROXIED_LEGACY = "src/test/repositories/legacy-proxied";
  95
  96     protected static final String REPOPATH_PROXIED1 = "src/test/repositories/proxied1";
  97
  98     protected static final String REPOPATH_PROXIED1_TARGET = "target/test-repository/proxied1";
  99
 100     protected static final String REPOPATH_PROXIED2 = "src/test/repositories/proxied2";
 101
 102     protected static final String REPOPATH_PROXIED2_TARGET = "target/test-repository/proxied2";
 103
 104     protected static final String REPOPATH_DEFAULT_MANAGED = "src/test/repositories/managed";
 105
 106     // protected static final String REPOPATH_DEFAULT_MANAGED_TARGET = "target/test-repository/managed";
 107
 108     protected static final String REPOPATH_LEGACY_MANAGED = "src/test/repositories/legacy-managed";
 109
 110     protected static final String REPOPATH_LEGACY_MANAGED_TARGET = "target/test-repository/legacy-managed";
 111
 112     protected IMocksControl wagonMockControl;
 113
 114     protected Wagon wagonMock;
 115
 116
 117     protected RepositoryProxyConnectors proxyHandler;
 118
 119     protected ManagedRepositoryContent managedDefaultRepository;
 120
 121     protected File managedDefaultDir;
 122
 123     protected ManagedRepositoryContent managedLegacyRepository;
 124
 125     protected File managedLegacyDir;
 126
 127     protected MockConfiguration config;
 128
 129     protected Logger log = LoggerFactory.getLogger( getClass() );
 130
 131     WagonDelegate delegate;
 132
 133     @Inject
 134     protected ManagedRepositoryAdmin managedRepositoryAdmin;
 135
 136     @Inject
 137     protected PlexusSisuBridge plexusSisuBridge;
 138
 139     @Before
 140     public void setUp()
 141         throws Exception
 142     {
 143         config =
 144             (MockConfiguration) applicationContext.getBean( "archivaConfiguration#mock", ArchivaConfiguration.class );
 145
 146         config.getConfiguration().setManagedRepositories( new ArrayList<ManagedRepositoryConfiguration>() );
 147         config.getConfiguration().setRemoteRepositories( new ArrayList<RemoteRepositoryConfiguration>() );
 148         config.getConfiguration().setProxyConnectors( new ArrayList<ProxyConnectorConfiguration>() );
 149
 150         // Setup source repository (using default layout)
 151         String name = getClass().getSimpleName();
 152         String repoPath = "target/test-repository/managed/" + name;
 153         File repoLocation = new File( repoPath );
 154
 155         managedDefaultRepository =
 156             createRepository( ID_DEFAULT_MANAGED, "Default Managed Repository", repoPath, "default" );
 157
 158         managedDefaultDir = new File( managedDefaultRepository.getRepoRoot() );
 159
 160         ManagedRepository repoConfig = managedDefaultRepository.getRepository();
 161
 162         ( (DefaultManagedRepositoryAdmin) applicationContext.getBean(
 163             ManagedRepositoryAdmin.class ) ).setArchivaConfiguration( config );
 164
 165         applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( repoConfig, false, null );
 166
 167         // to prevent windauze file leaking
 168         removeMavenIndexes();
 169
 170         // Setup source repository (using legacy layout)
 171         repoLocation = new File( REPOPATH_LEGACY_MANAGED_TARGET );
 172         if ( repoLocation.exists() )
 173         {
 174             FileUtils.deleteDirectory( repoLocation );
 175         }
 176         copyDirectoryStructure( new File( REPOPATH_LEGACY_MANAGED ), repoLocation );
 177
 178         managedLegacyRepository =
 179             createRepository( ID_LEGACY_MANAGED, "Legacy Managed Repository", REPOPATH_LEGACY_MANAGED_TARGET,
 180                               "legacy" );
 181
 182         managedLegacyDir = new File( managedLegacyRepository.getRepoRoot() );
 183
 184         repoConfig = managedLegacyRepository.getRepository();
 185
 186         applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( repoConfig, false, null );
 187
 188         // Setup target (proxied to) repository.
 189         saveRemoteRepositoryConfig( ID_PROXIED1, "Proxied Repository 1",
 190                                     new File( REPOPATH_PROXIED1 ).toURL().toExternalForm(), "default" );
 191
 192         // Setup target (proxied to) repository.
 193         saveRemoteRepositoryConfig( ID_PROXIED2, "Proxied Repository 2",
 194                                     new File( REPOPATH_PROXIED2 ).toURL().toExternalForm(), "default" );
 195
 196         // Setup target (proxied to) repository using legacy layout.
 197         saveRemoteRepositoryConfig( ID_LEGACY_PROXIED, "Proxied Legacy Repository",
 198                                     new File( REPOPATH_PROXIED_LEGACY ).toURL().toExternalForm(), "legacy" );
 199
 200         // Setup the proxy handler.
 201         //proxyHandler = applicationContext.getBean (RepositoryProxyConnectors) lookup( RepositoryProxyConnectors.class.getName() );
 202
 203         proxyHandler = applicationContext.getBean( "repositoryProxyConnectors#test", RepositoryProxyConnectors.class );
 204
 205         // Setup the wagon mock.
 206         wagonMockControl = EasyMock.createNiceControl( );
 207         wagonMock = wagonMockControl.createMock( Wagon.class );
 208
 209         delegate = (WagonDelegate) applicationContext.getBean( "wagon#test", Wagon.class );
 210
 211         delegate.setDelegate( wagonMock );
 212
 213         CacheManager.getInstance().clearAll();
 214
 215         log.info( "\n.\\ {}() \\._________________________________________\n", name );
 216     }
 217
 218     @After
 219     public void shutdown()
 220         throws Exception
 221     {
 222         removeMavenIndexes();
 223     }
 224
 225
 226     protected void removeMavenIndexes()
 227         throws Exception
 228     {
 229         NexusIndexer nexusIndexer = plexusSisuBridge.lookup( NexusIndexer.class );
 230
 231         for ( IndexingContext indexingContext : nexusIndexer.getIndexingContexts().values() )
 232         {
 233             nexusIndexer.removeIndexingContext( indexingContext, false );
 234         }
 235     }
 236
 237     /*
 238     protected static final ArgumentsMatcher customWagonGetIfNewerMatcher = new ArgumentsMatcher()
 239     {
 240
 241         public boolean matches( Object[] expected, Object[] actual )
 242         {
 243             if ( expected.length < 1 || actual.length < 1 )
 244             {
 245                 return false;
 246             }
 247             return MockControl.ARRAY_MATCHER.matches( ArrayUtils.remove( expected, 1 ),
 248                                                       ArrayUtils.remove( actual, 1 ) );
 249         }
 250
 251         public String toString( Object[] arguments )
 252         {
 253             return ArrayUtils.toString( arguments );
 254         }
 255     };
 256
 257     protected static final ArgumentsMatcher customWagonGetMatcher = new ArgumentsMatcher()
 258     {
 259
 260         public boolean matches( Object[] expected, Object[] actual )
 261         {
 262             if ( expected.length == 2 && actual.length == 2 )
 263             {
 264                 if ( expected[0] == null && actual[0] == null )
 265                 {
 266                     return true;
 267                 }
 268
 269                 if ( expected[0] == null )
 270                 {
 271                     return actual[0] == null;
 272                 }
 273
 274                 if ( actual[0] == null )
 275                 {
 276                     return expected[0] == null;
 277                 }
 278
 279                 return expected[0].equals( actual[0] );
 280             }
 281             return false;
 282         }
 283
 284         public String toString( Object[] arguments )
 285         {
 286             return ArrayUtils.toString( arguments );
 287         }
 288     };
 289     */
 290
 291     protected void assertChecksums( File expectedFile, String expectedSha1Contents, String expectedMd5Contents )
 292         throws Exception
 293     {
 294         File sha1File = new File( expectedFile.getAbsolutePath() + ".sha1" );
 295         File md5File = new File( expectedFile.getAbsolutePath() + ".md5" );
 296
 297         if ( expectedSha1Contents == null )
 298         {
 299             assertFalse( "SHA1 File should NOT exist: " + sha1File.getPath(), sha1File.exists() );
 300         }
 301         else
 302         {
 303             assertTrue( "SHA1 File should exist: " + sha1File.getPath(), sha1File.exists() );
 304             String actualSha1Contents = readChecksumFile( sha1File );
 305             assertEquals( "SHA1 File contents: " + sha1File.getPath(), expectedSha1Contents, actualSha1Contents );
 306         }
 307
 308         if ( expectedMd5Contents == null )
 309         {
 310             assertFalse( "MD5 File should NOT exist: " + md5File.getPath(), md5File.exists() );
 311         }
 312         else
 313         {
 314             assertTrue( "MD5 File should exist: " + md5File.getPath(), md5File.exists() );
 315             String actualMd5Contents = readChecksumFile( md5File );
 316             assertEquals( "MD5 File contents: " + md5File.getPath(), expectedMd5Contents, actualMd5Contents );
 317         }
 318     }
 319
 320     protected void assertFileEquals( File expectedFile, File actualFile, File sourceFile )
 321         throws Exception
 322     {
 323         assertNotNull( "Expected File should not be null.", expectedFile );
 324         assertNotNull( "Actual File should not be null.", actualFile );
 325
 326         assertTrue( "Check actual file exists.", actualFile.exists() );
 327         assertEquals( "Check filename path is appropriate.", expectedFile.getCanonicalPath(),
 328                       actualFile.getCanonicalPath() );
 329         assertEquals( "Check file path matches.", expectedFile.getAbsolutePath(), actualFile.getAbsolutePath() );
 330
 331         String expectedContents =
 332             org.apache.commons.io.FileUtils.readFileToString( sourceFile, Charset.defaultCharset() );
 333         String actualContents =
 334             org.apache.commons.io.FileUtils.readFileToString( actualFile, Charset.defaultCharset() );
 335         assertEquals( "Check file contents.", expectedContents, actualContents );
 336     }
 337
 338     protected void assertNotDownloaded( File downloadedFile )
 339     {
 340         assertNull( "Found file: " + downloadedFile + "; but was expecting a failure", downloadedFile );
 341     }
 342
 343     @SuppressWarnings ( "unchecked" )
 344     protected void assertNoTempFiles( File expectedFile )
 345     {
 346         File workingDir = expectedFile.getParentFile();
 347         if ( ( workingDir == null ) || !workingDir.isDirectory() )
 348         {
 349             return;
 350         }
 351
 352         Collection<File> tmpFiles =
 353             org.apache.commons.io.FileUtils.listFiles( workingDir, new String[]{ "tmp" }, false );
 354         if ( !tmpFiles.isEmpty() )
 355         {
 356             StringBuilder emsg = new StringBuilder();
 357             emsg.append( "Found Temp Files in dir: " ).append( workingDir.getPath() );
 358             for ( File tfile : tmpFiles )
 359             {
 360                 emsg.append( "\n   " ).append( tfile.getName() );
 361             }
 362             fail( emsg.toString() );
 363         }
 364     }
 365
 366     /**
 367      * A faster recursive copy that omits .svn directories.
 368      *
 369      * @param sourceDirectory the source directory to copy
 370      * @param destDirectory   the target location
 371      * @throws java.io.IOException if there is a copying problem
 372      * @todo get back into plexus-utils, share with converter module
 373      */
 374     protected void copyDirectoryStructure( File sourceDirectory, File destDirectory )
 375         throws IOException
 376     {
 377         if ( !sourceDirectory.exists() )
 378         {
 379             throw new IOException( "Source directory doesn't exists (" + sourceDirectory.getAbsolutePath() + ")." );
 380         }
 381
 382         File[] files = sourceDirectory.listFiles();
 383
 384         String sourcePath = sourceDirectory.getAbsolutePath();
 385
 386         for ( int i = 0; i < files.length; i++ )
 387         {
 388             File file = files[i];
 389
 390             String dest = file.getAbsolutePath();
 391
 392             dest = dest.substring( sourcePath.length() + 1 );
 393
 394             File destination = new File( destDirectory, dest );
 395
 396             if ( file.isFile() )
 397             {
 398                 destination = destination.getParentFile();
 399
 400                 org.apache.commons.io.FileUtils.copyFile( file, new File( destination, file.getName() ), false );
 401                 // TODO: Change when there is a FileUtils.copyFileToDirectory(file, destination, boolean) option
 402                 //FileUtils.copyFileToDirectory( file, destination );
 403             }
 404             else if ( file.isDirectory() )
 405             {
 406                 if ( !".svn".equals( file.getName() ) )
 407                 {
 408                     if ( !destination.exists() && !destination.mkdirs() )
 409                     {
 410                         throw new IOException(
 411                             "Could not create destination directory '" + destination.getAbsolutePath() + "'." );
 412                     }
 413
 414                     copyDirectoryStructure( file, destination );
 415                 }
 416             }
 417             else
 418             {
 419                 throw new IOException( "Unknown file type: " + file.getAbsolutePath() );
 420             }
 421         }
 422     }
 423
 424     protected ManagedRepositoryContent createManagedLegacyRepository()
 425         throws Exception
 426     {
 427         return createRepository( "testManagedLegacyRepo", "Test Managed (Legacy) Repository",
 428                                  "src/test/repositories/legacy-managed", "legacy" );
 429     }
 430
 431     protected ManagedRepositoryContent createProxiedLegacyRepository()
 432         throws Exception
 433     {
 434         return createRepository( "testProxiedLegacyRepo", "Test Proxied (Legacy) Repository",
 435                                  "src/test/repositories/legacy-proxied", "legacy" );
 436     }
 437
 438     protected ManagedRepositoryContent createRepository( String id, String name, String path, String layout )
 439         throws Exception
 440     {
 441         ManagedRepository repo = new ManagedRepository();
 442         repo.setId( id );
 443         repo.setName( name );
 444         repo.setLocation( path );
 445         repo.setLayout( layout );
 446
 447         ManagedRepositoryContent repoContent =
 448             applicationContext.getBean( "managedRepositoryContent#" + layout, ManagedRepositoryContent.class );
 449         repoContent.setRepository( repo );
 450         return repoContent;
 451     }
 452
 453     /**
 454      * Read the first line from the checksum file, and return it (trimmed).
 455      */
 456     protected String readChecksumFile( File checksumFile )
 457         throws Exception
 458     {
 459         FileReader freader = null;
 460         BufferedReader buf = null;
 461
 462         try
 463         {
 464             freader = new FileReader( checksumFile );
 465             buf = new BufferedReader( freader );
 466             return buf.readLine();
 467         }
 468         finally
 469         {
 470             if ( buf != null )
 471             {
 472                 buf.close();
 473             }
 474
 475             if ( freader != null )
 476             {
 477                 freader.close();
 478             }
 479         }
 480     }
 481
 482     protected void saveConnector( String sourceRepoId, String targetRepoId, boolean disabled )
 483     {
 484         saveConnector( sourceRepoId, targetRepoId, ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS, SnapshotsPolicy.ALWAYS,
 485                        CachedFailuresPolicy.NO, disabled );
 486     }
 487
 488     protected void saveConnector( String sourceRepoId, String targetRepoId, String checksumPolicy, String releasePolicy,
 489                                   String snapshotPolicy, String cacheFailuresPolicy, boolean disabled )
 490     {
 491         saveConnector( sourceRepoId, targetRepoId, checksumPolicy, releasePolicy, snapshotPolicy, cacheFailuresPolicy,
 492                        PropagateErrorsDownloadPolicy.QUEUE, disabled );
 493     }
 494
 495     protected void saveConnector( String sourceRepoId, String targetRepoId, String checksumPolicy, String releasePolicy,
 496                                   String snapshotPolicy, String cacheFailuresPolicy, String errorPolicy,
 497                                   boolean disabled )
 498     {
 499         saveConnector( sourceRepoId, targetRepoId, checksumPolicy, releasePolicy, snapshotPolicy, cacheFailuresPolicy,
 500                        errorPolicy, PropagateErrorsOnUpdateDownloadPolicy.NOT_PRESENT, disabled );
 501     }
 502
 503     protected void saveConnector( String sourceRepoId, String targetRepoId, String checksumPolicy, String releasePolicy,
 504                                   String snapshotPolicy, String cacheFailuresPolicy, String errorPolicy,
 505                                   String errorOnUpdatePolicy, boolean disabled )
 506     {
 507         ProxyConnectorConfiguration connectorConfig = new ProxyConnectorConfiguration();
 508         connectorConfig.setSourceRepoId( sourceRepoId );
 509         connectorConfig.setTargetRepoId( targetRepoId );
 510         connectorConfig.addPolicy( ProxyConnectorConfiguration.POLICY_CHECKSUM, checksumPolicy );
 511         connectorConfig.addPolicy( ProxyConnectorConfiguration.POLICY_RELEASES, releasePolicy );
 512         connectorConfig.addPolicy( ProxyConnectorConfiguration.POLICY_SNAPSHOTS, snapshotPolicy );
 513         connectorConfig.addPolicy( ProxyConnectorConfiguration.POLICY_CACHE_FAILURES, cacheFailuresPolicy );
 514         connectorConfig.addPolicy( ProxyConnectorConfiguration.POLICY_PROPAGATE_ERRORS, errorPolicy );
 515         connectorConfig.addPolicy( ProxyConnectorConfiguration.POLICY_PROPAGATE_ERRORS_ON_UPDATE, errorOnUpdatePolicy );
 516         connectorConfig.setDisabled( disabled );
 517
 518         int count = config.getConfiguration().getProxyConnectors().size();
 519         config.getConfiguration().addProxyConnector( connectorConfig );
 520
 521         // Proper Triggering ...
 522         String prefix = "proxyConnectors.proxyConnector(" + count + ")";
 523         config.triggerChange( prefix + ".sourceRepoId", connectorConfig.getSourceRepoId() );
 524         config.triggerChange( prefix + ".targetRepoId", connectorConfig.getTargetRepoId() );
 525         config.triggerChange( prefix + ".proxyId", connectorConfig.getProxyId() );
 526         config.triggerChange( prefix + ".policies.releases", connectorConfig.getPolicy( "releases", "" ) );
 527         config.triggerChange( prefix + ".policies.checksum", connectorConfig.getPolicy( "checksum", "" ) );
 528         config.triggerChange( prefix + ".policies.snapshots", connectorConfig.getPolicy( "snapshots", "" ) );
 529         config.triggerChange( prefix + ".policies.cache-failures", connectorConfig.getPolicy( "cache-failures", "" ) );
 530         config.triggerChange( prefix + ".policies.propagate-errors",
 531                               connectorConfig.getPolicy( "propagate-errors", "" ) );
 532         config.triggerChange( prefix + ".policies.propagate-errors-on-update",
 533                               connectorConfig.getPolicy( "propagate-errors-on-update", "" ) );
 534     }
 535
 536     protected void saveManagedRepositoryConfig( String id, String name, String path, String layout )
 537     {
 538         ManagedRepositoryConfiguration repoConfig = new ManagedRepositoryConfiguration();
 539
 540         repoConfig.setId( id );
 541         repoConfig.setName( name );
 542         repoConfig.setLayout( layout );
 543
 544         repoConfig.setLocation( path );
 545
 546         int count = config.getConfiguration().getManagedRepositories().size();
 547         config.getConfiguration().addManagedRepository( repoConfig );
 548
 549         String prefix = "managedRepositories.managedRepository(" + count + ")";
 550         config.triggerChange( prefix + ".id", repoConfig.getId() );
 551         config.triggerChange( prefix + ".name", repoConfig.getName() );
 552         config.triggerChange( prefix + ".location", repoConfig.getLocation() );
 553         config.triggerChange( prefix + ".layout", repoConfig.getLayout() );
 554     }
 555
 556     protected void saveRemoteRepositoryConfig( String id, String name, String url, String layout )
 557     {
 558         RemoteRepositoryConfiguration repoConfig = new RemoteRepositoryConfiguration();
 559
 560         repoConfig.setId( id );
 561         repoConfig.setName( name );
 562         repoConfig.setLayout( layout );
 563         repoConfig.setUrl( url );
 564
 565         int count = config.getConfiguration().getRemoteRepositories().size();
 566         config.getConfiguration().addRemoteRepository( repoConfig );
 567
 568         String prefix = "remoteRepositories.remoteRepository(" + count + ")";
 569         config.triggerChange( prefix + ".id", repoConfig.getId() );
 570         config.triggerChange( prefix + ".name", repoConfig.getName() );
 571         config.triggerChange( prefix + ".url", repoConfig.getUrl() );
 572         config.triggerChange( prefix + ".layout", repoConfig.getLayout() );
 573     }
 574
 575     protected File saveTargetedRepositoryConfig( String id, String originalPath, String targetPath, String layout )
 576         throws IOException
 577     {
 578         File repoLocation = new File( targetPath );
 579         FileUtils.deleteDirectory( repoLocation );
 580         copyDirectoryStructure( new File( originalPath ), repoLocation );
 581
 582         saveRemoteRepositoryConfig( id, "Target Repo-" + id, targetPath, layout );
 583
 584         return repoLocation;
 585     }
 586
 587
 588     /**
 589      * Copy the specified resource directory from the src/test/repository/managed/ to
 590      * the testable directory under target/test-repository/managed/${testName}/
 591      *
 592      * @param resourcePath
 593      * @throws IOException
 594      */
 595     protected void setupTestableManagedRepository( String resourcePath )
 596         throws IOException
 597     {
 598         String resourceDir = resourcePath;
 599
 600         if ( !resourcePath.endsWith( "/" ) )
 601         {
 602             int idx = resourcePath.lastIndexOf( '/' );
 603             resourceDir = resourcePath.substring( 0, idx );
 604         }
 605
 606         File sourceRepoDir = new File( REPOPATH_DEFAULT_MANAGED );
 607         File sourceDir = new File( sourceRepoDir, resourceDir );
 608
 609         File destRepoDir = managedDefaultDir;
 610         File destDir = new File( destRepoDir, resourceDir );
 611
 612         // Cleanout destination dirs.
 613         if ( destDir.exists() )
 614         {
 615             FileUtils.deleteDirectory( destDir );
 616         }
 617
 618         // Make the destination dir.
 619         destDir.mkdirs();
 620
 621         // Test the source dir.
 622         if ( !sourceDir.exists() )
 623         {
 624             // This is just a warning.
 625             System.err.println(
 626                 "[WARN] Skipping setup of testable managed repository, source dir does not exist: " + sourceDir );
 627         }
 628         else
 629         {
 630
 631             // Test that the source is a dir.
 632             if ( !sourceDir.isDirectory() )
 633             {
 634                 fail( "Unable to setup testable managed repository, source is not a directory: " + sourceDir );
 635             }
 636
 637             // Copy directory structure.
 638             copyDirectoryStructure( sourceDir, destDir );
 639         }
 640     }
 641
 642     protected void setManagedNewerThanRemote( File managedFile, File remoteFile )
 643     {
 644         setManagedNewerThanRemote( managedFile, remoteFile, 55000 );
 645     }
 646
 647     protected void setManagedNewerThanRemote( File managedFile, File remoteFile, long time )
 648     {
 649         assertTrue( "Managed File should exist: ", managedFile.exists() );
 650         assertTrue( "Remote File should exist: ", remoteFile.exists() );
 651
 652         managedFile.setLastModified( remoteFile.lastModified() + time );
 653
 654         assertTrue( managedFile.lastModified() > remoteFile.lastModified() );
 655     }
 656
 657     protected void setManagedOlderThanRemote( File managedFile, File remoteFile )
 658     {
 659         setManagedOlderThanRemote( managedFile, remoteFile, 55000 );
 660     }
 661
 662     protected void setManagedOlderThanRemote( File managedFile, File remoteFile, long time )
 663     {
 664         assertTrue( "Managed File should exist: ", managedFile.exists() );
 665         assertTrue( "Remote File should exist: ", remoteFile.exists() );
 666
 667         managedFile.setLastModified( remoteFile.lastModified() - time );
 668
 669         assertTrue( managedFile.lastModified() < remoteFile.lastModified() );
 670
 671     }
 672
 673     protected void assertNotModified( File file, long expectedModificationTime )
 674     {
 675         assertEquals( "File <" + file.getAbsolutePath() + "> not have been modified.", expectedModificationTime,
 676                       file.lastModified() );
 677     }
 678
 679     protected void assertNotExistsInManagedLegacyRepo( File file )
 680         throws Exception
 681     {
 682         String managedLegacyPath = managedLegacyDir.getCanonicalPath();
 683         String testFile = file.getCanonicalPath();
 684
 685         assertTrue(
 686             "Unit Test Failure: File <" + testFile + "> should be have been defined within the legacy managed path of <"
 687                 + managedLegacyPath + ">", testFile.startsWith( managedLegacyPath ) );
 688
 689         assertFalse( "File < " + testFile + "> should not exist in managed legacy repository.", file.exists() );
 690     }
 691
 692     protected void assertNotExistsInManagedDefaultRepo( File file )
 693         throws Exception
 694     {
 695         String managedDefaultPath = managedDefaultDir.getCanonicalPath();
 696         String testFile = file.getCanonicalPath();
 697
 698         assertTrue( "Unit Test Failure: File <" + testFile
 699                         + "> should be have been defined within the managed default path of <" + managedDefaultPath
 700                         + ">", testFile.startsWith( managedDefaultPath ) );
 701
 702         assertFalse( "File < " + testFile + "> should not exist in managed default repository.", file.exists() );
 703     }
 704
 705     protected static Date getFutureDate()
 706         throws ParseException
 707     {
 708         Calendar cal = Calendar.getInstance();
 709         cal.add( Calendar.YEAR, 1 );
 710         return cal.getTime();
 711     }
 712
 713     protected static Date getPastDate()
 714         throws ParseException
 715     {
 716         return new SimpleDateFormat( "yyyy-MM-dd", Locale.US ).parse( "2000-01-01" );
 717     }
 718 }