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