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