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