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