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

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