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