1 package org.apache.archiva.converter.artifact;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
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
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
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
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
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
317 }
318
319 private void doTestV4SnapshotPomConvert( String version, String expectedMetadataFileName )
320 throws Exception
321 {
322
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
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
435
436
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
444
445
446
447
448
449
450
451 }
452
453 @Test
454 public void testV3TimestampedSnapshotPomConvert()
455 throws Exception
456 {
457
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
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
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
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
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
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
608
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
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
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
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
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
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
745 Thread.sleep( SLEEP_MILLIS );
746
747
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
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
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
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
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
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
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
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. " + converter.getWarnings(), 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
1033 return;
1034 }
1035 }
1036
1037
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 }