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