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

   1 package org.apache.maven.repository.converter;
   2
   3 /*
   4  * Copyright 2005-2006 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import org.apache.maven.artifact.Artifact;
  20 import org.apache.maven.artifact.factory.ArtifactFactory;
  21 import org.apache.maven.artifact.metadata.ArtifactMetadata;
  22 import org.apache.maven.artifact.repository.ArtifactRepository;
  23 import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
  24 import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
  25 import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
  26 import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
  27 import org.apache.maven.repository.reporting.ArtifactReporter;
  28 import org.apache.maven.repository.reporting.ArtifactResult;
  29 import org.apache.maven.repository.reporting.DefaultArtifactReporter;
  30 import org.codehaus.plexus.PlexusTestCase;
  31 import org.codehaus.plexus.i18n.I18N;
  32 import org.codehaus.plexus.util.FileUtils;
  33
  34 import java.io.File;
  35 import java.io.IOException;
  36 import java.net.MalformedURLException;
  37 import java.util.ArrayList;
  38 import java.util.Iterator;
  39 import java.util.List;
  40 import java.util.Locale;
  41 import java.util.regex.Matcher;
  42
  43 /**
  44  * Test the repository converter.
  45  *
  46  * @author <a href="mailto:brett@apache.org">Brett Porter</a>
  47  * @todo what about deletions from the source repository?
  48  * @todo use artifact-test instead
  49  * @todo should reject if dependencies are missing - rely on reporting?
  50  * @todo group metadata
  51  */
  52 public class RepositoryConverterTest
  53     extends PlexusTestCase
  54 {
  55     private ArtifactRepository sourceRepository;
  56
  57     private ArtifactRepository targetRepository;
  58
  59     private RepositoryConverter repositoryConverter;
  60
  61     private ArtifactFactory artifactFactory;
  62
  63     private ArtifactReporter reporter;
  64
  65     private static final int SLEEP_MILLIS = 100;
  66
  67     private I18N i18n;
  68
  69     protected void setUp()
  70         throws Exception
  71     {
  72         super.setUp();
  73
  74         ArtifactRepositoryFactory factory = (ArtifactRepositoryFactory) lookup( ArtifactRepositoryFactory.ROLE );
  75
  76         ArtifactRepositoryLayout layout = (ArtifactRepositoryLayout) lookup( ArtifactRepositoryLayout.ROLE, "legacy" );
  77
  78         File sourceBase = getTestFile( "src/test/source-repository" );
  79         sourceRepository =
  80             factory.createArtifactRepository( "source", sourceBase.toURL().toString(), layout, null, null );
  81
  82         layout = (ArtifactRepositoryLayout) lookup( ArtifactRepositoryLayout.ROLE, "default" );
  83
  84         File targetBase = getTestFile( "target/test-target-repository" );
  85         FileUtils.copyDirectoryStructure( getTestFile( "src/test/target-repository" ), targetBase );
  86
  87         targetRepository =
  88             factory.createArtifactRepository( "target", targetBase.toURL().toString(), layout, null, null );
  89
  90         repositoryConverter = (RepositoryConverter) lookup( RepositoryConverter.ROLE, "default" );
  91
  92         artifactFactory = (ArtifactFactory) lookup( ArtifactFactory.ROLE );
  93
  94         i18n = (I18N) lookup( I18N.ROLE );
  95
  96         reporter = new DefaultArtifactReporter();
  97     }
  98
  99     public void testV4PomConvert()
 100         throws IOException, RepositoryConversionException
 101     {
 102         // test that it is copied as is
 103
 104         Artifact artifact = createArtifact( "test", "v4artifact", "1.0.0" );
 105         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 106         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 107                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 108         artifactMetadataFile.delete();
 109
 110         ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 111         File versionMetadataFile = new File( targetRepository.getBasedir(),
 112                                              targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
 113         versionMetadataFile.delete();
 114
 115         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 116         artifactFile.delete();
 117
 118         repositoryConverter.convert( artifact, targetRepository, reporter );
 119         checkSuccess();
 120
 121         assertTrue( "Check artifact created", artifactFile.exists() );
 122         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 123
 124         artifact = createPomArtifact( artifact );
 125         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 126         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 127         assertTrue( "Check POM created", pomFile.exists() );
 128
 129         compareFiles( sourcePomFile, pomFile );
 130
 131         assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
 132
 133         File expectedMetadataFile = getTestFile( "src/test/expected-files/v4-artifact-metadata.xml" );
 134
 135         compareFiles( expectedMetadataFile, artifactMetadataFile );
 136
 137         assertTrue( "Check snapshot metadata created", versionMetadataFile.exists() );
 138
 139         expectedMetadataFile = getTestFile( "src/test/expected-files/v4-version-metadata.xml" );
 140
 141         compareFiles( expectedMetadataFile, versionMetadataFile );
 142     }
 143
 144     public void testV3PomConvert()
 145         throws IOException, RepositoryConversionException
 146     {
 147         // test that the pom is coverted
 148
 149         Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0" );
 150         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 151         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 152                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 153         artifactMetadataFile.delete();
 154
 155         ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 156         File versionMetadataFile = new File( targetRepository.getBasedir(),
 157                                              targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
 158         versionMetadataFile.delete();
 159
 160         repositoryConverter.convert( artifact, targetRepository, reporter );
 161         checkSuccess();
 162
 163         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 164         assertTrue( "Check artifact created", artifactFile.exists() );
 165         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 166
 167         artifact = createPomArtifact( artifact );
 168         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 169         File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3.pom" );
 170         assertTrue( "Check POM created", pomFile.exists() );
 171
 172         compareFiles( expectedPomFile, pomFile );
 173
 174         assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
 175
 176         File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-artifact-metadata.xml" );
 177
 178         compareFiles( expectedMetadataFile, artifactMetadataFile );
 179
 180         assertTrue( "Check snapshot metadata created", versionMetadataFile.exists() );
 181
 182         expectedMetadataFile = getTestFile( "src/test/expected-files/v3-version-metadata.xml" );
 183
 184         compareFiles( expectedMetadataFile, versionMetadataFile );
 185     }
 186
 187     public void testV3PomWarningsOnConvert()
 188         throws RepositoryConversionException, IOException
 189     {
 190         // test that the pom is converted but that warnings are reported
 191
 192         Artifact artifact = createArtifact( "test", "v3-warnings-artifact", "1.0.0" );
 193         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 194         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 195                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 196         artifactMetadataFile.delete();
 197
 198         ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 199         File versionMetadataFile = new File( targetRepository.getBasedir(),
 200                                              targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
 201         versionMetadataFile.delete();
 202
 203         repositoryConverter.convert( artifact, targetRepository, reporter );
 204         assertEquals( "check no errors", 0, reporter.getFailures() );
 205         assertEquals( "check number of warnings", 2, reporter.getWarnings() );
 206         assertEquals( "check success", 1, reporter.getSuccesses() );
 207
 208         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 209         assertTrue( "Check artifact created", artifactFile.exists() );
 210         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 211
 212         artifact = createPomArtifact( artifact );
 213         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 214         File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-warnings.pom" );
 215         assertTrue( "Check POM created", pomFile.exists() );
 216
 217         compareFiles( expectedPomFile, pomFile );
 218
 219         // TODO: check 2 warnings (extend and versions) matched on i18n key
 220     }
 221
 222     public void testV4SnapshotPomConvert()
 223         throws IOException, RepositoryConversionException
 224     {
 225         // test that it is copied as is
 226
 227         Artifact artifact = createArtifact( "test", "v4artifact", "1.0.0-SNAPSHOT" );
 228         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 229         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 230                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 231         artifactMetadataFile.delete();
 232
 233         ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 234         File snapshotMetadataFile = new File( targetRepository.getBasedir(),
 235                                               targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
 236         snapshotMetadataFile.delete();
 237
 238         repositoryConverter.convert( artifact, targetRepository, reporter );
 239         checkSuccess();
 240
 241         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 242         assertTrue( "Check artifact created", artifactFile.exists() );
 243         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 244
 245         artifact = createPomArtifact( artifact );
 246         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 247         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 248         assertTrue( "Check POM created", pomFile.exists() );
 249
 250         compareFiles( sourcePomFile, pomFile );
 251
 252         assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
 253
 254         File expectedMetadataFile = getTestFile( "src/test/expected-files/v4-snapshot-artifact-metadata.xml" );
 255
 256         compareFiles( expectedMetadataFile, artifactMetadataFile );
 257
 258         assertTrue( "Check snapshot metadata created", snapshotMetadataFile.exists() );
 259
 260         expectedMetadataFile = getTestFile( "src/test/expected-files/v4-snapshot-metadata.xml" );
 261
 262         compareFiles( expectedMetadataFile, snapshotMetadataFile );
 263     }
 264
 265     public void testV3SnapshotPomConvert()
 266         throws IOException, RepositoryConversionException
 267     {
 268         // test that the pom is coverted
 269
 270         Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0-SNAPSHOT" );
 271         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 272         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 273                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 274         artifactMetadataFile.delete();
 275
 276         ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 277         File snapshotMetadataFile = new File( targetRepository.getBasedir(),
 278                                               targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
 279         snapshotMetadataFile.delete();
 280
 281         repositoryConverter.convert( artifact, targetRepository, reporter );
 282         checkSuccess();
 283
 284         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 285         assertTrue( "Check artifact created", artifactFile.exists() );
 286         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 287
 288         artifact = createPomArtifact( artifact );
 289         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 290         File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-snapshot.pom" );
 291         assertTrue( "Check POM created", pomFile.exists() );
 292
 293         compareFiles( expectedPomFile, pomFile );
 294
 295         assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
 296
 297         File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-artifact-metadata.xml" );
 298
 299         compareFiles( expectedMetadataFile, artifactMetadataFile );
 300
 301         assertTrue( "Check snapshot metadata created", snapshotMetadataFile.exists() );
 302
 303         expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-metadata.xml" );
 304
 305         compareFiles( expectedMetadataFile, snapshotMetadataFile );
 306     }
 307
 308     public void testV4TimestampedSnapshotPomConvert()
 309         throws IOException, RepositoryConversionException
 310     {
 311         // test that it is copied as is
 312
 313         Artifact artifact = createArtifact( "test", "v4artifact", "1.0.0-20060111.120115-1" );
 314         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 315         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 316                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 317         artifactMetadataFile.delete();
 318
 319         ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 320         File snapshotMetadataFile = new File( targetRepository.getBasedir(),
 321                                               targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
 322         snapshotMetadataFile.delete();
 323
 324         repositoryConverter.convert( artifact, targetRepository, reporter );
 325         checkSuccess();
 326
 327         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 328         assertTrue( "Check artifact created", artifactFile.exists() );
 329         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 330
 331         artifact = createPomArtifact( artifact );
 332         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 333         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 334         assertTrue( "Check POM created", pomFile.exists() );
 335
 336         compareFiles( sourcePomFile, pomFile );
 337
 338         assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
 339
 340         File expectedMetadataFile = getTestFile( "src/test/expected-files/v4-snapshot-artifact-metadata.xml" );
 341
 342         compareFiles( expectedMetadataFile, artifactMetadataFile );
 343
 344         assertTrue( "Check snapshot metadata created", snapshotMetadataFile.exists() );
 345
 346         expectedMetadataFile = getTestFile( "src/test/expected-files/v4-timestamped-snapshot-metadata.xml" );
 347
 348         compareFiles( expectedMetadataFile, snapshotMetadataFile );
 349     }
 350
 351     public void testV3TimestampedSnapshotPomConvert()
 352         throws IOException, RepositoryConversionException
 353     {
 354         // test that the pom is coverted
 355
 356         Artifact artifact = createArtifact( "test", "v3artifact", "1.0.0-20060105.130101-3" );
 357         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 358         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 359                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 360         artifactMetadataFile.delete();
 361
 362         ArtifactMetadata snapshotMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 363         File snapshotMetadataFile = new File( targetRepository.getBasedir(),
 364                                               targetRepository.pathOfRemoteRepositoryMetadata( snapshotMetadata ) );
 365         snapshotMetadataFile.delete();
 366
 367         repositoryConverter.convert( artifact, targetRepository, reporter );
 368         checkSuccess();
 369
 370         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 371         assertTrue( "Check artifact created", artifactFile.exists() );
 372         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 373
 374         artifact = createPomArtifact( artifact );
 375         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 376         File expectedPomFile = getTestFile( "src/test/expected-files/converted-v3-timestamped-snapshot.pom" );
 377         assertTrue( "Check POM created", pomFile.exists() );
 378
 379         compareFiles( expectedPomFile, pomFile );
 380
 381         assertTrue( "Check artifact snapshotMetadata created", artifactMetadataFile.exists() );
 382
 383         File expectedMetadataFile = getTestFile( "src/test/expected-files/v3-snapshot-artifact-metadata.xml" );
 384
 385         compareFiles( expectedMetadataFile, artifactMetadataFile );
 386
 387         assertTrue( "Check snapshot snapshotMetadata created", snapshotMetadataFile.exists() );
 388
 389         expectedMetadataFile = getTestFile( "src/test/expected-files/v3-timestamped-snapshot-metadata.xml" );
 390
 391         compareFiles( expectedMetadataFile, snapshotMetadataFile );
 392     }
 393
 394     public void testNoPomConvert()
 395         throws IOException, RepositoryConversionException
 396     {
 397         // test that a POM is not created when there was none at the source
 398
 399         Artifact artifact = createArtifact( "test", "noPomArtifact", "1.0.0" );
 400         repositoryConverter.convert( artifact, targetRepository, reporter );
 401         assertEquals( "check no errors", 0, reporter.getFailures() );
 402         assertEquals( "check no warnings", 1, reporter.getWarnings() );
 403         assertEquals( "check success", 1, reporter.getSuccesses() );
 404         assertEquals( "check warning message", getI18nString( "warning.missing.pom" ), getWarning().getReason() );
 405
 406         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 407         assertTrue( "Check artifact created", artifactFile.exists() );
 408         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 409
 410         artifact = createPomArtifact( artifact );
 411         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 412         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 413
 414         assertFalse( "Check no POM created", pomFile.exists() );
 415         assertFalse( "No source POM", sourcePomFile.exists() );
 416     }
 417
 418     public void testIncorrectSourceChecksumMd5()
 419         throws RepositoryConversionException
 420     {
 421         // test that it fails when the source md5 is wrong
 422
 423         Artifact artifact = createArtifact( "test", "incorrectMd5Artifact", "1.0.0" );
 424         File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 425         file.delete();
 426
 427         repositoryConverter.convert( artifact, targetRepository, reporter );
 428         checkFailure();
 429         assertEquals( "check failure message", getI18nString( "failure.incorrect.md5" ), getFailure().getReason() );
 430
 431         assertFalse( "Check artifact not created", file.exists() );
 432
 433         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 434         File metadataFile =
 435             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 436         assertFalse( "Check metadata not created", metadataFile.exists() );
 437     }
 438
 439     public void testIncorrectSourceChecksumSha1()
 440         throws RepositoryConversionException
 441     {
 442         // test that it fails when the source sha1 is wrong
 443
 444         Artifact artifact = createArtifact( "test", "incorrectSha1Artifact", "1.0.0" );
 445         File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 446         file.delete();
 447
 448         repositoryConverter.convert( artifact, targetRepository, reporter );
 449         checkFailure();
 450         assertEquals( "check failure message", getI18nString( "failure.incorrect.sha1" ), getFailure().getReason() );
 451
 452         assertFalse( "Check artifact not created", file.exists() );
 453
 454         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 455         File metadataFile =
 456             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 457         assertFalse( "Check metadata not created", metadataFile.exists() );
 458     }
 459
 460     public void testUnmodifiedArtifact()
 461         throws RepositoryConversionException, IOException, InterruptedException
 462     {
 463         // test the unmodified artifact is untouched
 464
 465         Artifact artifact = createArtifact( "test", "unmodified-artifact", "1.0.0" );
 466         Artifact pomArtifact = createPomArtifact( artifact );
 467
 468         File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 469         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
 470         File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 471         File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
 472
 473         assertTrue( "Check target file exists", targetFile.exists() );
 474         assertTrue( "Check target POM exists", targetPomFile.exists() );
 475
 476         sourceFile.setLastModified( System.currentTimeMillis() );
 477         sourcePomFile.setLastModified( System.currentTimeMillis() );
 478
 479         long origTime = targetFile.lastModified();
 480         long origPomTime = targetPomFile.lastModified();
 481
 482         // Need to guarantee last modified is not equal
 483         Thread.sleep( SLEEP_MILLIS );
 484
 485         repositoryConverter.convert( artifact, targetRepository, reporter );
 486         checkSuccess();
 487
 488         compareFiles( sourceFile, targetFile );
 489         compareFiles( sourcePomFile, targetPomFile );
 490
 491         assertEquals( "Check unmodified", origTime, targetFile.lastModified() );
 492         assertEquals( "Check unmodified", origPomTime, targetPomFile.lastModified() );
 493     }
 494
 495     public void testModifedArtifactFails()
 496         throws InterruptedException, RepositoryConversionException, IOException
 497     {
 498         // test that it fails when the source artifact has changed and is different to the existing artifact in the
 499         // target repository
 500
 501         Artifact artifact = createArtifact( "test", "modified-artifact", "1.0.0" );
 502         Artifact pomArtifact = createPomArtifact( artifact );
 503
 504         File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 505         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
 506         File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 507         File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
 508
 509         assertTrue( "Check target file exists", targetFile.exists() );
 510         assertTrue( "Check target POM exists", targetPomFile.exists() );
 511
 512         sourceFile.setLastModified( System.currentTimeMillis() );
 513         sourcePomFile.setLastModified( System.currentTimeMillis() );
 514
 515         long origTime = targetFile.lastModified();
 516         long origPomTime = targetPomFile.lastModified();
 517
 518         // Need to guarantee last modified is not equal
 519         Thread.sleep( SLEEP_MILLIS );
 520
 521         repositoryConverter.convert( artifact, targetRepository, reporter );
 522         checkFailure();
 523         assertEquals( "Check failure message", getI18nString( "failure.target.already.exists" ),
 524                       getFailure().getReason() );
 525
 526         assertEquals( "Check unmodified", origTime, targetFile.lastModified() );
 527         assertEquals( "Check unmodified", origPomTime, targetPomFile.lastModified() );
 528
 529         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 530         File metadataFile =
 531             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 532         assertFalse( "Check metadata not created", metadataFile.exists() );
 533     }
 534
 535     public void testForcedUnmodifiedArtifact()
 536         throws Exception, IOException
 537     {
 538         // test unmodified artifact is still converted when set to force
 539
 540         repositoryConverter = (RepositoryConverter) lookup( RepositoryConverter.ROLE, "force-repository-converter" );
 541
 542         Artifact artifact = createArtifact( "test", "unmodified-artifact", "1.0.0" );
 543         Artifact pomArtifact = createPomArtifact( artifact );
 544
 545         File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 546         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
 547         File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 548         File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
 549
 550         long origTime = targetFile.lastModified();
 551         long origPomTime = targetPomFile.lastModified();
 552
 553         sourceFile.setLastModified( System.currentTimeMillis() );
 554         sourcePomFile.setLastModified( System.currentTimeMillis() );
 555
 556         // Need to guarantee last modified is not equal
 557         Thread.sleep( SLEEP_MILLIS );
 558
 559         repositoryConverter.convert( artifact, targetRepository, reporter );
 560         checkSuccess();
 561
 562         compareFiles( sourceFile, targetFile );
 563         compareFiles( sourcePomFile, targetPomFile );
 564
 565         assertFalse( "Check modified", origTime == targetFile.lastModified() );
 566         assertFalse( "Check modified", origPomTime == targetPomFile.lastModified() );
 567
 568         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 569         File metadataFile =
 570             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 571         assertTrue( "Check metadata created", metadataFile.exists() );
 572     }
 573
 574     public void testDryRunSuccess()
 575         throws Exception
 576     {
 577         // test dry run does nothing on a run that will be successful, and returns success
 578
 579         repositoryConverter = (RepositoryConverter) lookup( RepositoryConverter.ROLE, "dryrun-repository-converter" );
 580
 581         Artifact artifact = createArtifact( "test", "dryrun-artifact", "1.0.0" );
 582         Artifact pomArtifact = createPomArtifact( artifact );
 583
 584         File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 585         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
 586         File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 587         File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
 588
 589         repositoryConverter.convert( artifact, targetRepository, reporter );
 590         checkSuccess();
 591
 592         assertTrue( "Check source file exists", sourceFile.exists() );
 593         assertTrue( "Check source POM exists", sourcePomFile.exists() );
 594
 595         assertFalse( "Check target file doesn't exist", targetFile.exists() );
 596         assertFalse( "Check target POM doesn't exist", targetPomFile.exists() );
 597
 598         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 599         File metadataFile =
 600             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 601         assertFalse( "Check metadata not created", metadataFile.exists() );
 602     }
 603
 604     public void testDryRunFailure()
 605         throws Exception
 606     {
 607         // test dry run does nothing on a run that will fail, and returns failure
 608
 609         repositoryConverter = (RepositoryConverter) lookup( RepositoryConverter.ROLE, "dryrun-repository-converter" );
 610
 611         Artifact artifact = createArtifact( "test", "modified-artifact", "1.0.0" );
 612         Artifact pomArtifact = createPomArtifact( artifact );
 613
 614         File sourceFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 615         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( pomArtifact ) );
 616         File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 617         File targetPomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pomArtifact ) );
 618
 619         assertTrue( "Check target file exists", targetFile.exists() );
 620         assertTrue( "Check target POM exists", targetPomFile.exists() );
 621
 622         sourceFile.setLastModified( System.currentTimeMillis() );
 623         sourcePomFile.setLastModified( System.currentTimeMillis() );
 624
 625         long origTime = targetFile.lastModified();
 626         long origPomTime = targetPomFile.lastModified();
 627
 628         // Need to guarantee last modified is not equal
 629         Thread.sleep( SLEEP_MILLIS );
 630
 631         repositoryConverter.convert( artifact, targetRepository, reporter );
 632         checkFailure();
 633         assertEquals( "Check failure message", getI18nString( "failure.target.already.exists" ),
 634                       getFailure().getReason() );
 635
 636         assertEquals( "Check unmodified", origTime, targetFile.lastModified() );
 637         assertEquals( "Check unmodified", origPomTime, targetPomFile.lastModified() );
 638
 639         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 640         File metadataFile =
 641             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 642         assertFalse( "Check metadata not created", metadataFile.exists() );
 643     }
 644
 645     public void testRollbackArtifactCreated()
 646         throws RepositoryConversionException, IOException
 647     {
 648         // test rollback can remove a created artifact, including checksums
 649
 650         Artifact artifact = createArtifact( "test", "rollback-created-artifact", "1.0.0" );
 651         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 652         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 653                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 654         FileUtils.deleteDirectory( artifactMetadataFile.getParentFile() );
 655
 656         ArtifactMetadata versionMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 657         File versionMetadataFile = new File( targetRepository.getBasedir(),
 658                                              targetRepository.pathOfRemoteRepositoryMetadata( versionMetadata ) );
 659
 660         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 661
 662         repositoryConverter.convert( artifact, targetRepository, reporter );
 663         checkFailure();
 664         String pattern = "^" + getI18nString( "failure.invalid.source.pom" ).replace( "{0}", "(.*?)" ) + "$";
 665         assertTrue( "Check failure message", getFailure().getReason().matches( pattern ) );
 666
 667         assertFalse( "check artifact rolled back", artifactFile.exists() );
 668         assertFalse( "check metadata rolled back", artifactMetadataFile.exists() );
 669         assertFalse( "check metadata rolled back", versionMetadataFile.exists() );
 670     }
 671
 672     public void testMultipleArtifacts()
 673         throws RepositoryConversionException, IOException
 674     {
 675         // test multiple artifacts are converted
 676
 677         List artifacts = new ArrayList();
 678         artifacts.add( createArtifact( "test", "artifact-one", "1.0.0" ) );
 679         artifacts.add( createArtifact( "test", "artifact-two", "1.0.0" ) );
 680         artifacts.add( createArtifact( "test", "artifact-three", "1.0.0" ) );
 681         repositoryConverter.convert( artifacts, targetRepository, reporter );
 682         assertEquals( "check no errors", 0, reporter.getFailures() );
 683         assertEquals( "check no warnings", 0, reporter.getWarnings() );
 684         assertEquals( "check successes", 3, reporter.getSuccesses() );
 685
 686         for ( Iterator i = artifacts.iterator(); i.hasNext(); )
 687         {
 688             Artifact artifact = (Artifact) i.next();
 689
 690             File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 691             assertTrue( "Check artifact created", artifactFile.exists() );
 692             assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 693
 694             artifact = createPomArtifact( artifact );
 695             File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 696             File expectedPomFile =
 697                 getTestFile( "src/test/expected-files/converted-" + artifact.getArtifactId() + ".pom" );
 698             assertTrue( "Check POM created", pomFile.exists() );
 699
 700             compareFiles( expectedPomFile, pomFile );
 701         }
 702     }
 703
 704     public void testInvalidSourceArtifactMetadata()
 705         throws Exception
 706     {
 707         // test artifact is not converted when source metadata is invalid, and returns failure
 708
 709         createModernSourceRepository();
 710
 711         Artifact artifact = createArtifact( "test", "incorrectArtifactMetadata", "1.0.0" );
 712         File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 713         file.delete();
 714
 715         repositoryConverter.convert( artifact, targetRepository, reporter );
 716         checkFailure();
 717         assertEquals( "check failure message", getI18nString( "failure.incorrect.artifactMetadata.versions" ),
 718                       getFailure().getReason() );
 719
 720         assertFalse( "Check artifact not created", file.exists() );
 721
 722         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 723         File metadataFile =
 724             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 725         assertFalse( "Check metadata not created", metadataFile.exists() );
 726     }
 727
 728     public void testInvalidSourceSnapshotMetadata()
 729         throws Exception, MalformedURLException
 730     {
 731         // test artifact is not converted when source snapshot metadata is invalid and returns failure
 732
 733         createModernSourceRepository();
 734
 735         Artifact artifact = createArtifact( "test", "incorrectSnapshotMetadata", "1.0.0-20060102.030405-6" );
 736         File file = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 737         file.delete();
 738
 739         repositoryConverter.convert( artifact, targetRepository, reporter );
 740         checkFailure();
 741         assertEquals( "check failure message", getI18nString( "failure.incorrect.snapshotMetadata.snapshot" ),
 742                       getFailure().getReason() );
 743
 744         assertFalse( "Check artifact not created", file.exists() );
 745
 746         ArtifactRepositoryMetadata metadata = new ArtifactRepositoryMetadata( artifact );
 747         File metadataFile =
 748             new File( targetRepository.getBasedir(), targetRepository.pathOfRemoteRepositoryMetadata( metadata ) );
 749         assertFalse( "Check metadata not created", metadataFile.exists() );
 750     }
 751
 752     public void testMergeArtifactMetadata()
 753         throws RepositoryConversionException, IOException
 754     {
 755         // test artifact level metadata is merged when it already exists on successful conversion
 756
 757         Artifact artifact = createArtifact( "test", "newversion-artifact", "1.0.1" );
 758
 759         repositoryConverter.convert( artifact, targetRepository, reporter );
 760         checkSuccess();
 761
 762         File artifactFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 763         assertTrue( "Check artifact created", artifactFile.exists() );
 764         assertTrue( "Check artifact matches", FileUtils.contentEquals( artifactFile, artifact.getFile() ) );
 765
 766         artifact = createPomArtifact( artifact );
 767         File pomFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 768         File sourcePomFile = new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) );
 769         assertTrue( "Check POM created", pomFile.exists() );
 770
 771         compareFiles( sourcePomFile, pomFile );
 772
 773         ArtifactMetadata artifactMetadata = new ArtifactRepositoryMetadata( artifact );
 774         File artifactMetadataFile = new File( targetRepository.getBasedir(),
 775                                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 776         assertTrue( "Check artifact metadata created", artifactMetadataFile.exists() );
 777
 778         File expectedMetadataFile = getTestFile( "src/test/expected-files/newversion-artifact-metadata.xml" );
 779
 780         compareFiles( expectedMetadataFile, artifactMetadataFile );
 781     }
 782
 783     public void testSourceAndTargetRepositoriesMatch()
 784         throws Exception
 785     {
 786         // test that it fails if the same
 787
 788         ArtifactRepositoryFactory factory = (ArtifactRepositoryFactory) lookup( ArtifactRepositoryFactory.ROLE );
 789
 790         sourceRepository = factory.createArtifactRepository( "source", targetRepository.getUrl(),
 791                                                              targetRepository.getLayout(), null, null );
 792
 793         Artifact artifact = createArtifact( "test", "repository-artifact", "1.0" );
 794
 795         try
 796         {
 797             repositoryConverter.convert( artifact, targetRepository, reporter );
 798             fail( "Should have failed trying to convert within the same repository" );
 799         }
 800         catch ( RepositoryConversionException e )
 801         {
 802             // expected
 803             assertEquals( "check message", getI18nString( "exception.repositories.match" ), e.getMessage() );
 804             assertNull( "Check no additional cause", e.getCause() );
 805         }
 806     }
 807
 808     private Artifact createArtifact( String groupId, String artifactId, String version )
 809     {
 810         Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( version );
 811         String baseVersion;
 812         if ( matcher.matches() )
 813         {
 814             baseVersion = matcher.group( 1 ) + "-SNAPSHOT";
 815         }
 816         else
 817         {
 818             baseVersion = version;
 819         }
 820         return createArtifact( groupId, artifactId, baseVersion, version, "jar" );
 821     }
 822
 823     private Artifact createArtifact( String groupId, String artifactId, String baseVersion, String version,
 824                                      String type )
 825     {
 826         Artifact artifact = artifactFactory.createArtifact( groupId, artifactId, version, null, type );
 827         artifact.setBaseVersion( baseVersion );
 828         artifact.setRepository( sourceRepository );
 829         artifact.setFile( new File( sourceRepository.getBasedir(), sourceRepository.pathOf( artifact ) ) );
 830         return artifact;
 831     }
 832
 833     private Artifact createPomArtifact( Artifact artifact )
 834     {
 835         return createArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact.getBaseVersion(),
 836                                artifact.getVersion(), "pom" );
 837     }
 838
 839     private static void compareFiles( File expectedPomFile, File pomFile )
 840         throws IOException
 841     {
 842         String expectedContent = normalizeString( FileUtils.fileRead( expectedPomFile ) );
 843         String targetContent = normalizeString( FileUtils.fileRead( pomFile ) );
 844         assertEquals( "Check file match between " + expectedPomFile + " and " + pomFile, expectedContent,
 845                       targetContent );
 846     }
 847
 848     private static String normalizeString( String path )
 849     {
 850         return path.trim().replaceAll( "\r\n", "\n" ).replace( '\r', '\n' );
 851     }
 852
 853     private void checkSuccess()
 854     {
 855         assertEquals( "check no errors", 0, reporter.getFailures() );
 856         assertEquals( "check no warnings", 0, reporter.getWarnings() );
 857         assertEquals( "check success", 1, reporter.getSuccesses() );
 858     }
 859
 860     private void checkFailure()
 861     {
 862         assertEquals( "check num errors", 1, reporter.getFailures() );
 863         assertEquals( "check no warnings", 0, reporter.getWarnings() );
 864         assertEquals( "check no success", 0, reporter.getSuccesses() );
 865     }
 866
 867     private String getI18nString( String key )
 868     {
 869         return i18n.getString( repositoryConverter.getClass().getName(), Locale.getDefault(), key );
 870     }
 871
 872     private ArtifactResult getFailure()
 873     {
 874         return (ArtifactResult) reporter.getArtifactFailureIterator().next();
 875     }
 876
 877     private ArtifactResult getWarning()
 878     {
 879         return (ArtifactResult) reporter.getArtifactWarningIterator().next();
 880     }
 881
 882     private void createModernSourceRepository()
 883         throws Exception
 884     {
 885         ArtifactRepositoryFactory factory = (ArtifactRepositoryFactory) lookup( ArtifactRepositoryFactory.ROLE );
 886
 887         ArtifactRepositoryLayout layout = (ArtifactRepositoryLayout) lookup( ArtifactRepositoryLayout.ROLE, "default" );
 888
 889         File sourceBase = getTestFile( "src/test/source-modern-repository" );
 890         sourceRepository =
 891             factory.createArtifactRepository( "source", sourceBase.toURL().toString(), layout, null, null );
 892     }
 893
 894 }