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