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

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