1 package org.apache.maven.archiver;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.apache.maven.artifact.Artifact;
23 import org.apache.maven.artifact.DependencyResolutionRequiredException;
24 import org.apache.maven.artifact.handler.ArtifactHandler;
25 import org.apache.maven.artifact.handler.DefaultArtifactHandler;
26 import org.apache.maven.artifact.repository.ArtifactRepository;
27 import org.apache.maven.execution.DefaultMavenExecutionRequest;
28 import org.apache.maven.execution.DefaultMavenExecutionResult;
29 import org.apache.maven.execution.MavenExecutionRequest;
30 import org.apache.maven.execution.MavenExecutionResult;
31 import org.apache.maven.execution.MavenSession;
32 import org.apache.maven.model.Build;
33 import org.apache.maven.model.Model;
34 import org.apache.maven.model.Organization;
35 import org.apache.maven.project.MavenProject;
36 import org.apache.maven.shared.utils.StringUtils;
37 import org.apache.maven.shared.utils.io.FileUtils;
38 import org.apache.maven.shared.utils.io.IOUtil;
39 import org.codehaus.plexus.PlexusContainer;
40 import org.codehaus.plexus.archiver.jar.JarArchiver;
41 import org.codehaus.plexus.archiver.jar.ManifestException;
42 import org.junit.Test;
43 import org.sonatype.aether.RepositorySystemSession;
44 import org.sonatype.aether.util.DefaultRepositorySystemSession;
45
46 import java.io.File;
47 import java.io.IOException;
48 import java.io.InputStream;
49 import java.net.URI;
50 import java.net.URL;
51 import java.util.ArrayList;
52 import java.util.Collections;
53 import java.util.Comparator;
54 import java.util.Date;
55 import java.util.HashMap;
56 import java.util.List;
57 import java.util.Map;
58 import java.util.Properties;
59 import java.util.Set;
60 import java.util.TreeSet;
61 import java.util.jar.Attributes;
62 import java.util.jar.JarFile;
63 import java.util.jar.Manifest;
64 import java.util.zip.ZipEntry;
65
66 import static org.junit.Assert.*;
67
68 public class MavenArchiverTest
69 {
70 static class ArtifactComparator
71 implements Comparator<Artifact>
72 {
73 public int compare( Artifact o1, Artifact o2 )
74 {
75 return o1.getArtifactId().compareTo( o2.getArtifactId() );
76 }
77
78 public boolean equals( Object o )
79 {
80 return false;
81 }
82 }
83
84 @Test
85 public void testGetManifestExtensionList()
86 throws Exception
87 {
88 MavenArchiver archiver = new MavenArchiver();
89
90 MavenSession session = getDummySession();
91
92 Model model = new Model();
93 model.setArtifactId( "dummy" );
94
95 MavenProject project = new MavenProject( model );
96
97 Set<Artifact> artifacts = new TreeSet<Artifact>( new ArtifactComparator() );
98 project.setArtifacts( artifacts );
99
100
101 ManifestConfiguration config = new ManifestConfiguration()
102 {
103 public boolean isAddExtensions()
104 {
105 return true;
106 }
107 };
108
109 Manifest manifest;
110
111 manifest = archiver.getManifest( session, project, config );
112
113 assertNotNull( manifest.getMainAttributes() );
114
115 assertEquals( null, manifest.getMainAttributes().getValue( "Extension-List" ) );
116
117 MockArtifact artifact1 = new MockArtifact();
118 artifact1.setGroupId( "org.apache.dummy" );
119 artifact1.setArtifactId( "dummy1" );
120 artifact1.setVersion( "1.0" );
121 artifact1.setType( "dll" );
122 artifact1.setScope( "compile" );
123
124 artifacts.add( artifact1 );
125
126 manifest = archiver.getManifest( session, project, config );
127
128 assertEquals( null, manifest.getMainAttributes().getValue( "Extension-List" ) );
129
130 MockArtifact artifact2 = new MockArtifact();
131 artifact2.setGroupId( "org.apache.dummy" );
132 artifact2.setArtifactId( "dummy2" );
133 artifact2.setVersion( "1.0" );
134 artifact2.setType( "jar" );
135 artifact2.setScope( "compile" );
136
137 artifacts.add( artifact2 );
138
139 manifest = archiver.getManifest( session, project, config );
140
141 assertEquals( "dummy2", manifest.getMainAttributes().getValue( "Extension-List" ) );
142
143 MockArtifact artifact3 = new MockArtifact();
144 artifact3.setGroupId( "org.apache.dummy" );
145 artifact3.setArtifactId( "dummy3" );
146 artifact3.setVersion( "1.0" );
147 artifact3.setScope( "test" );
148 artifact3.setType( "jar" );
149
150 artifacts.add( artifact3 );
151
152 manifest = archiver.getManifest( session, project, config );
153
154 assertEquals( "dummy2", manifest.getMainAttributes().getValue( "Extension-List" ) );
155
156 MockArtifact artifact4 = new MockArtifact();
157 artifact4.setGroupId( "org.apache.dummy" );
158 artifact4.setArtifactId( "dummy4" );
159 artifact4.setVersion( "1.0" );
160 artifact4.setType( "jar" );
161 artifact4.setScope( "compile" );
162
163 artifacts.add( artifact4 );
164
165 manifest = archiver.getManifest( session, project, config );
166
167 assertEquals( "dummy2 dummy4", manifest.getMainAttributes().getValue( "Extension-List" ) );
168 }
169
170 @Test
171 public void testMultiClassPath()
172 throws Exception
173 {
174 final File tempFile = File.createTempFile( "maven-archiver-test-", ".jar" );
175
176 try
177 {
178 MavenArchiver archiver = new MavenArchiver();
179
180 MavenSession session = getDummySession();
181
182 Model model = new Model();
183 model.setArtifactId( "dummy" );
184
185 MavenProject project = new MavenProject( model)
186 {
187 public List<String> getRuntimeClasspathElements()
188 {
189 return Collections.singletonList( tempFile.getAbsolutePath() );
190 }
191 };
192
193
194 ManifestConfiguration manifestConfig = new ManifestConfiguration()
195 {
196 public boolean isAddClasspath()
197 {
198 return true;
199 }
200 };
201
202 MavenArchiveConfiguration archiveConfiguration = new MavenArchiveConfiguration();
203 archiveConfiguration.setManifest( manifestConfig );
204 archiveConfiguration.addManifestEntry( "Class-Path", "help/" );
205
206 Manifest manifest = archiver.getManifest( session, project, archiveConfiguration );
207 String classPath = manifest.getMainAttributes().getValue( "Class-Path" );
208 assertTrue( "User specified Class-Path entry was not added to manifest", classPath.contains( "help/" ) );
209 assertTrue( "Class-Path generated by addClasspath was not added to manifest",
210 classPath.contains( tempFile.getName() ) );
211 }
212 finally
213 {
214
215 tempFile.delete();
216 }
217 }
218
219 @Test
220 public void testRecreation()
221 throws Exception
222 {
223 File jarFile = new File( "target/test/dummy.jar" );
224 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
225
226 MavenArchiver archiver = getMavenArchiver( jarArchiver );
227
228 MavenSession session = getDummySession();
229 MavenProject project = getDummyProject();
230
231 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
232 config.setForced( false );
233
234 FileUtils.deleteDirectory( "target/maven-archiver" );
235 archiver.createArchive( session, project, config );
236 assertTrue( jarFile.exists() );
237 jarFile.setLastModified( System.currentTimeMillis() - 60000L );
238 long time = jarFile.lastModified();
239
240 List<File> files = FileUtils.getFiles( new File( "target/maven-archiver" ), "**/**", null, true );
241 for ( Object file : files )
242 {
243 File f = (File) file;
244 f.setLastModified( time );
245 }
246
247 archiver.createArchive( session, project, config );
248 assertEquals( jarFile.lastModified(), time );
249
250 config.setForced( true );
251 archiver.createArchive( session, project, config );
252 assertTrue( jarFile.lastModified() > time );
253 }
254
255 @Test
256 public void testNotGenerateImplementationVersionForMANIFESTMF()
257 throws Exception
258 {
259 JarFile jar = null;
260 try
261 {
262 File jarFile = new File( "target/test/dummy.jar" );
263 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
264
265 MavenArchiver archiver = getMavenArchiver( jarArchiver );
266
267 MavenSession session = getDummySession();
268 MavenProject project = getDummyProject();
269
270 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
271 config.setForced( true );
272 config.getManifest().setAddDefaultImplementationEntries( false );
273 archiver.createArchive( session, project, config );
274 assertTrue( jarFile.exists() );
275
276 jar = new JarFile( jarFile );
277 Map<Object, Object> entries = jar.getManifest().getMainAttributes();
278 assertFalse( entries.containsKey( Attributes.Name.IMPLEMENTATION_VERSION ) );
279 }
280 finally
281 {
282
283 if ( jar != null )
284 {
285 jar.close();
286 }
287 }
288 }
289
290 @Test
291 public void testGenerateImplementationVersionForMANIFESTMF()
292 throws Exception
293 {
294 JarFile jar = null;
295 try
296 {
297 File jarFile = new File( "target/test/dummy.jar" );
298 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
299
300 MavenArchiver archiver = getMavenArchiver( jarArchiver );
301
302 MavenSession session = getDummySession();
303 MavenProject project = getDummyProject();
304
305 String ls = System.getProperty( "line.separator" );
306 project.setDescription( "foo " + ls + " bar " );
307 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
308 config.setForced( true );
309 config.getManifest().setAddDefaultImplementationEntries( true );
310 config.addManifestEntry( "Description", project.getDescription() );
311 archiver.createArchive( session, project, config );
312 assertTrue( jarFile.exists() );
313
314 jar = new JarFile( jarFile );
315
316 Map<Object, Object> entries = jar.getManifest().getMainAttributes();
317
318 assertTrue( entries.containsKey( Attributes.Name.IMPLEMENTATION_VERSION ) );
319 assertEquals( "0.1.1", entries.get( Attributes.Name.IMPLEMENTATION_VERSION ) );
320 }
321 finally
322 {
323
324 if ( jar != null )
325 {
326 jar.close();
327 }
328 }
329 }
330
331 private MavenArchiver getMavenArchiver( JarArchiver jarArchiver )
332 {
333 MavenArchiver archiver = new MavenArchiver();
334 archiver.setArchiver( jarArchiver );
335 archiver.setOutputFile( jarArchiver.getDestFile() );
336 return archiver;
337 }
338
339 @Test
340 public void testDashesInClassPath_MSHARED_134()
341 throws IOException, ManifestException, DependencyResolutionRequiredException
342 {
343 File jarFile = new File( "target/test/dummyWithDashes.jar" );
344 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
345
346 MavenArchiver archiver = getMavenArchiver( jarArchiver );
347
348 MavenSession session = getDummySession();
349 MavenProject project = getDummyProject();
350
351 Set<Artifact> artifacts =
352 getArtifacts( getMockArtifact1(), getArtifactWithDot(), getMockArtifact2(), getMockArtifact3() );
353
354 project.setArtifacts( artifacts );
355
356 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
357 config.setForced( false );
358
359 final ManifestConfiguration mftConfig = config.getManifest();
360 mftConfig.setMainClass( "org.apache.maven.Foo" );
361 mftConfig.setAddClasspath( true );
362 mftConfig.setAddExtensions( true );
363 mftConfig.setClasspathPrefix( "./lib/" );
364
365 archiver.createArchive( session, project, config );
366 assertTrue( jarFile.exists() );
367 }
368
369 @Test
370 public void testDashesInClassPath_MSHARED_182()
371 throws IOException, ManifestException, DependencyResolutionRequiredException
372 {
373 File jarFile = new File( "target/test/dummy.jar" );
374 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
375 MavenArchiver archiver = getMavenArchiver( jarArchiver );
376
377 MavenSession session = getDummySession();
378 MavenProject project = getDummyProject();
379
380 Set<Artifact> artifacts =
381 getArtifacts( getMockArtifact1(), getArtifactWithDot(), getMockArtifact2(), getMockArtifact3() );
382
383 project.setArtifacts( artifacts );
384
385 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
386 config.setForced( false );
387
388 final ManifestConfiguration mftConfig = config.getManifest();
389 mftConfig.setMainClass( "org.apache.maven.Foo" );
390 mftConfig.setAddClasspath( true );
391 mftConfig.setAddExtensions( true );
392 mftConfig.setClasspathPrefix( "./lib/" );
393 config.addManifestEntry( "Key1", "value1" );
394 config.addManifestEntry( "key2", "value2" );
395
396 archiver.createArchive( session, project, config );
397 assertTrue( jarFile.exists() );
398 final Attributes mainAttributes = getJarFileManifest( jarFile ).getMainAttributes();
399 assertEquals( "value1", mainAttributes.getValue( "Key1" ) );
400 assertEquals( "value2", mainAttributes.getValue( "Key2" ) );
401 }
402
403 @Test
404 public void testCarriageReturnInManifestEntry()
405 throws Exception
406 {
407 File jarFile = new File( "target/test/dummy.jar" );
408 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
409
410 MavenArchiver archiver = getMavenArchiver( jarArchiver );
411
412 MavenSession session = getDummySession();
413 MavenProject project = getDummyProject();
414
415 String ls = System.getProperty( "line.separator" );
416 project.setDescription( "foo " + ls + " bar " );
417 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
418 config.setForced( true );
419 config.getManifest().setAddDefaultImplementationEntries( true );
420 config.addManifestEntry( "Description", project.getDescription() );
421
422
423 archiver.createArchive( session, project, config );
424 assertTrue( jarFile.exists() );
425
426 final Manifest manifest = getJarFileManifest( jarFile );
427 Attributes attributes = manifest.getMainAttributes();
428 assertTrue( project.getDescription().indexOf( ls ) > 0 );
429 Attributes.Name description = new Attributes.Name( "Description" );
430 String value = attributes.getValue( description );
431 assertNotNull( value );
432 assertFalse( value.indexOf( ls ) > 0 );
433 }
434
435 @Test
436 public void testDeprecatedCreateArchiveAPI()
437 throws Exception
438 {
439 File jarFile = new File( "target/test/dummy.jar" );
440 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
441
442 MavenArchiver archiver = getMavenArchiver( jarArchiver );
443
444 MavenProject project = getDummyProject();
445 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
446 config.setForced( true );
447 config.getManifest().setAddDefaultImplementationEntries( true );
448 config.getManifest().setAddDefaultSpecificationEntries( true );
449
450
451 MavenSession session = getDummySessionWithoutMavenVersion();
452 archiver.createArchive( session, project, config );
453 assertTrue( jarFile.exists() );
454 Attributes manifest = getJarFileManifest( jarFile ).getMainAttributes();
455
456 assertEquals( "Apache Maven", manifest.get( new Attributes.Name( "Created-By" ) ) );
457
458 assertEquals( "archiver test", manifest.get( Attributes.Name.SPECIFICATION_TITLE ) );
459 assertEquals( "0.1", manifest.get( Attributes.Name.SPECIFICATION_VERSION ) );
460 assertEquals( "Apache", manifest.get( Attributes.Name.SPECIFICATION_VENDOR ) );
461
462 assertEquals( "archiver test", manifest.get( Attributes.Name.IMPLEMENTATION_TITLE ) );
463 assertEquals( "0.1.1", manifest.get( Attributes.Name.IMPLEMENTATION_VERSION ) );
464 assertEquals( "org.apache.dummy", manifest.get( Attributes.Name.IMPLEMENTATION_VENDOR_ID ) );
465 assertEquals( "Apache", manifest.get( Attributes.Name.IMPLEMENTATION_VENDOR ) );
466 assertEquals( "http://maven.apache.org", manifest.get( Attributes.Name.IMPLEMENTATION_URL ) );
467
468 assertEquals( System.getProperty( "java.version" ), manifest.get( new Attributes.Name( "Build-Jdk" ) ) );
469 assertEquals( System.getProperty( "user.name" ), manifest.get( new Attributes.Name( "Built-By" ) ) );
470 }
471
472 @Test
473 public void testManifestEntries()
474 throws Exception
475 {
476 File jarFile = new File( "target/test/dummy.jar" );
477 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
478
479 MavenArchiver archiver = getMavenArchiver( jarArchiver );
480
481 MavenSession session = getDummySession();
482 MavenProject project = getDummyProject();
483 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
484 config.setForced( true );
485 config.getManifest().setAddDefaultImplementationEntries( true );
486 config.getManifest().setAddDefaultSpecificationEntries( true );
487
488 Map<String, String> manifestEntries = new HashMap<String, String>();
489 manifestEntries.put( "foo", "bar" );
490 manifestEntries.put( "first-name", "olivier" );
491 manifestEntries.put( "keyWithEmptyValue", null );
492 config.setManifestEntries( manifestEntries );
493
494 ManifestSection manifestSection = new ManifestSection();
495 manifestSection.setName( "UserSection" );
496 manifestSection.addManifestEntry( "key", "value" );
497 List<ManifestSection> manifestSections = new ArrayList<ManifestSection>();
498 manifestSections.add( manifestSection );
499 config.setManifestSections( manifestSections );
500 config.getManifest().setMainClass( "org.apache.maven.Foo" );
501 archiver.createArchive( session, project, config );
502 assertTrue( jarFile.exists() );
503
504 final Manifest jarFileManifest = getJarFileManifest( jarFile );
505 Attributes manifest = jarFileManifest.getMainAttributes();
506
507 assertEquals( "Apache Maven 3.0.4", manifest.get( new Attributes.Name( "Created-By" ) ) );
508
509 assertEquals( "archiver test", manifest.get( Attributes.Name.SPECIFICATION_TITLE ) );
510 assertEquals( "0.1", manifest.get( Attributes.Name.SPECIFICATION_VERSION ) );
511 assertEquals( "Apache", manifest.get( Attributes.Name.SPECIFICATION_VENDOR ) );
512
513 assertEquals( "archiver test", manifest.get( Attributes.Name.IMPLEMENTATION_TITLE ) );
514 assertEquals( "0.1.1", manifest.get( Attributes.Name.IMPLEMENTATION_VERSION ) );
515 assertEquals( "org.apache.dummy", manifest.get( Attributes.Name.IMPLEMENTATION_VENDOR_ID ) );
516 assertEquals( "Apache", manifest.get( Attributes.Name.IMPLEMENTATION_VENDOR ) );
517 assertEquals( "http://maven.apache.org", manifest.get( Attributes.Name.IMPLEMENTATION_URL ) );
518
519 assertEquals( "org.apache.maven.Foo", manifest.get( Attributes.Name.MAIN_CLASS ) );
520
521 assertEquals( "bar", manifest.get( new Attributes.Name( "foo" ) ) );
522 assertEquals( "olivier", manifest.get( new Attributes.Name( "first-name" ) ) );
523
524 assertEquals( System.getProperty( "java.version" ), manifest.get( new Attributes.Name( "Build-Jdk" ) ) );
525 assertEquals( System.getProperty( "user.name" ), manifest.get( new Attributes.Name( "Built-By" ) ) );
526
527 assertTrue( StringUtils.isEmpty( manifest.getValue( new Attributes.Name( "keyWithEmptyValue" ) ) ) );
528 assertTrue( manifest.containsKey( new Attributes.Name( "keyWithEmptyValue" ) ) );
529
530 manifest = jarFileManifest.getAttributes( "UserSection" );
531
532 assertEquals( "value", manifest.get( new Attributes.Name( "key" ) ) );
533 }
534
535 @Test
536 public void testCreatedByManifestEntryWithoutMavenVersion()
537 throws Exception
538 {
539 File jarFile = new File( "target/test/dummy.jar" );
540 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
541
542 MavenArchiver archiver = getMavenArchiver( jarArchiver );
543
544 MavenSession session = getDummySessionWithoutMavenVersion();
545 MavenProject project = getDummyProject();
546
547 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
548 config.setForced( true );
549
550 archiver.createArchive( session, project, config );
551 assertTrue( jarFile.exists() );
552
553 final Manifest manifest = getJarFileManifest( jarFile );
554 Map<Object, Object> entries = manifest.getMainAttributes();
555
556 assertEquals( "Apache Maven", entries.get( new Attributes.Name( "Created-By" ) ) );
557 }
558
559
560
561
562 @Test
563 public void testManifestSections()
564 throws Exception
565 {
566 MavenArchiver archiver = new MavenArchiver();
567
568 MavenSession session = getDummySession();
569
570 MavenProject project = getDummyProject();
571 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
572
573 ManifestSection manifestSection = new ManifestSection();
574 manifestSection.setName( "SectionOne" );
575 manifestSection.addManifestEntry( "key", "value" );
576 List<ManifestSection> manifestSections = new ArrayList<ManifestSection>();
577 manifestSections.add( manifestSection );
578 config.setManifestSections( manifestSections );
579
580 Manifest manifest = archiver.getManifest( session, project, config );
581
582 Attributes section = manifest.getAttributes( "SectionOne" );
583 assertNotNull( "The section is not present in the manifest as it should be.", section );
584
585 String attribute = section.getValue( "key" );
586 assertNotNull( "The attribute we are looking for is not present in the section.", attribute );
587 assertEquals( "The value of the attribute is wrong.", "value", attribute );
588 }
589
590 @Test
591 public void testDefaultClassPathValue()
592 throws Exception
593 {
594 MavenSession session = getDummySession();
595 MavenProject project = getDummyProject();
596 File jarFile = new File( "target/test/dummy.jar" );
597 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
598
599 MavenArchiver archiver = getMavenArchiver( jarArchiver );
600
601 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
602 config.setForced( true );
603 config.getManifest().setAddDefaultImplementationEntries( true );
604 config.getManifest().setAddDefaultSpecificationEntries( true );
605 config.getManifest().setMainClass( "org.apache.maven.Foo" );
606 config.getManifest().setAddClasspath( true );
607 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
608 config.getManifest().setCustomClasspathLayout( "${artifact.artifactId}-${artifact.version}${dashClassifier?}.${artifact.extension}" );
609 archiver.createArchive( session, project, config );
610 assertTrue( jarFile.exists() );
611 final Manifest manifest = getJarFileManifest( jarFile );
612 String classPath = manifest.getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
613 assertNotNull( classPath );
614 String[] classPathEntries = StringUtils.split( classPath, " " );
615 assertEquals( "dummy1-1.0.jar", classPathEntries[0] );
616 assertEquals( "dummy2-1.5.jar", classPathEntries[1] );
617 assertEquals( "dummy3-2.0.jar", classPathEntries[2] );
618 }
619
620 private void deleteAndAssertNotPresent( File jarFile )
621 {
622 jarFile.delete();
623 assertFalse( jarFile.exists() );
624 }
625
626 @Test
627 public void testDefaultClassPathValue_WithSnapshot()
628 throws Exception
629 {
630 MavenSession session = getDummySession();
631 MavenProject project = getDummyProjectWithSnapshot();
632 File jarFile = new File( "target/test/dummy.jar" );
633 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
634
635 MavenArchiver archiver = getMavenArchiver( jarArchiver );
636
637 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
638 config.setForced( true );
639 config.getManifest().setAddDefaultImplementationEntries( true );
640 config.getManifest().setAddDefaultSpecificationEntries( true );
641 config.getManifest().setMainClass( "org.apache.maven.Foo" );
642 config.getManifest().setAddClasspath( true );
643 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
644 config.getManifest().setCustomClasspathLayout( "${artifact.artifactId}-${artifact.version}${dashClassifier?}.${artifact.extension}" );
645 archiver.createArchive( session, project, config );
646 assertTrue( jarFile.exists() );
647
648 final Manifest manifest = getJarFileManifest( jarFile );
649 String classPath = manifest.getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
650 assertNotNull( classPath );
651 String[] classPathEntries = StringUtils.split( classPath, " " );
652 assertEquals( "dummy1-1.1-20081022.112233-1.jar", classPathEntries[0] );
653 assertEquals( "dummy2-1.5.jar", classPathEntries[1] );
654 assertEquals( "dummy3-2.0.jar", classPathEntries[2] );
655 }
656
657 @Test
658 public void testMavenRepoClassPathValue()
659 throws Exception
660 {
661 MavenSession session = getDummySession();
662 MavenProject project = getDummyProject();
663 File jarFile = new File( "target/test/dummy.jar" );
664 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
665
666 MavenArchiver archiver = getMavenArchiver( jarArchiver );
667
668 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
669 config.setForced( true );
670 config.getManifest().setAddDefaultImplementationEntries( true );
671 config.getManifest().setAddDefaultSpecificationEntries( true );
672 config.getManifest().setMainClass( "org.apache.maven.Foo" );
673 config.getManifest().setAddClasspath( true );
674 config.getManifest().setUseUniqueVersions( true );
675 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_REPOSITORY );
676 archiver.createArchive( session, project, config );
677 assertTrue( jarFile.exists() );
678 Manifest manifest = archiver.getManifest( session, project, config );
679 String[] classPathEntries =
680 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
681 assertEquals( "org/apache/dummy/dummy1/1.0.1/dummy1-1.0.jar", classPathEntries[0] );
682 assertEquals( "org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
683 assertEquals( "org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
684
685 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
686 assertNotNull( classPath );
687 classPathEntries = StringUtils.split( classPath, " " );
688 assertEquals( "org/apache/dummy/dummy1/1.0.1/dummy1-1.0.jar", classPathEntries[0] );
689 assertEquals( "org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
690 assertEquals( "org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
691 }
692
693 @Test
694 public void shouldCreateArchiveWithSimpleClassPathLayoutWhileSettingSimpleLayoutExplicit()
695 throws Exception
696 {
697 MavenSession session = getDummySession();
698 MavenProject project = getDummyProject();
699 File jarFile = new File( "target/test/dummy-explicit-simple.jar" );
700 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
701
702 MavenArchiver archiver = getMavenArchiver( jarArchiver );
703
704 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
705 config.setForced( true );
706 config.getManifest().setAddDefaultImplementationEntries( true );
707 config.getManifest().setAddDefaultSpecificationEntries( true );
708 config.getManifest().setMainClass( "org.apache.maven.Foo" );
709 config.getManifest().setAddClasspath( true );
710 config.getManifest().setClasspathPrefix( "lib" );
711 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_SIMPLE );
712
713 archiver.createArchive( session, project, config );
714 assertTrue( jarFile.exists() );
715 Manifest manifest = archiver.getManifest( session, project, config );
716 String[] classPathEntries =
717 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
718 assertEquals( "lib/dummy1-1.0.jar", classPathEntries[0] );
719 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
720 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
721
722 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
723
724 assertNotNull( classPath );
725 classPathEntries = StringUtils.split( classPath, " " );
726 assertEquals( "lib/dummy1-1.0.jar", classPathEntries[0] );
727 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
728 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
729 }
730
731 @Test
732 public void shouldCreateArchiveCustomerLayoutSimple()
733 throws Exception
734 {
735 MavenSession session = getDummySession();
736 MavenProject project = getDummyProject();
737 File jarFile = new File( "target/test/dummy-custom-layout-simple.jar" );
738 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
739
740 MavenArchiver archiver = getMavenArchiver( jarArchiver );
741
742 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
743 config.setForced( true );
744 config.getManifest().setAddDefaultImplementationEntries( true );
745 config.getManifest().setAddDefaultSpecificationEntries( true );
746 config.getManifest().setMainClass( "org.apache.maven.Foo" );
747 config.getManifest().setAddClasspath( true );
748 config.getManifest().setClasspathPrefix( "lib" );
749 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
750 config.getManifest().setCustomClasspathLayout( MavenArchiver.SIMPLE_LAYOUT);
751
752 archiver.createArchive( session, project, config );
753 assertTrue( jarFile.exists() );
754 Manifest manifest = archiver.getManifest( session, project, config );
755 String[] classPathEntries =
756 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
757 assertEquals( "lib/dummy1-1.0.jar", classPathEntries[0] );
758 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
759 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
760
761 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
762
763 assertNotNull( classPath );
764 classPathEntries = StringUtils.split( classPath, " " );
765 assertEquals( "lib/dummy1-1.0.jar", classPathEntries[0] );
766 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
767 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
768 }
769
770 @Test
771 public void shouldCreateArchiveCustomLayoutSimpleNonUnique()
772 throws Exception
773 {
774 MavenSession session = getDummySession();
775 MavenProject project = getDummyProject();
776 File jarFile = new File( "target/test/dummy-custom-layout-simple-non-unique.jar" );
777 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
778
779 MavenArchiver archiver = getMavenArchiver( jarArchiver );
780
781 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
782 config.setForced( true );
783 config.getManifest().setAddDefaultImplementationEntries( true );
784 config.getManifest().setAddDefaultSpecificationEntries( true );
785 config.getManifest().setMainClass( "org.apache.maven.Foo" );
786 config.getManifest().setAddClasspath( true );
787 config.getManifest().setClasspathPrefix( "lib" );
788 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
789 config.getManifest().setCustomClasspathLayout( MavenArchiver.SIMPLE_LAYOUT_NONUNIQUE);
790
791 archiver.createArchive( session, project, config );
792 assertTrue( jarFile.exists() );
793 Manifest manifest = archiver.getManifest( session, project, config );
794 String[] classPathEntries =
795 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
796 assertEquals( "lib/dummy1-1.0.1.jar", classPathEntries[0] );
797 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
798 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
799
800 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
801
802 assertNotNull( classPath );
803 classPathEntries = StringUtils.split( classPath, " " );
804 assertEquals( "lib/dummy1-1.0.1.jar", classPathEntries[0] );
805 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
806 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
807 }
808
809 @Test
810 public void shouldCreateArchiveCustomLayoutRepository()
811 throws Exception
812 {
813 MavenSession session = getDummySession();
814 MavenProject project = getDummyProject();
815 File jarFile = new File( "target/test/dummy-custom-layout-repo.jar" );
816 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
817
818 MavenArchiver archiver = getMavenArchiver( jarArchiver );
819
820 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
821 config.setForced( true );
822 config.getManifest().setAddDefaultImplementationEntries( true );
823 config.getManifest().setAddDefaultSpecificationEntries( true );
824 config.getManifest().setMainClass( "org.apache.maven.Foo" );
825 config.getManifest().setAddClasspath( true );
826 config.getManifest().setClasspathPrefix( "lib" );
827 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
828 config.getManifest().setCustomClasspathLayout( MavenArchiver.REPOSITORY_LAYOUT );
829
830 archiver.createArchive( session, project, config );
831 assertTrue( jarFile.exists() );
832 Manifest manifest = archiver.getManifest( session, project, config );
833 String[] classPathEntries =
834 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
835 assertEquals( "lib/org/apache/dummy/dummy1/1.0.1/dummy1-1.0.jar", classPathEntries[0] );
836 assertEquals( "lib/org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
837 assertEquals( "lib/org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
838
839 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
840
841 assertNotNull( classPath );
842 classPathEntries = StringUtils.split( classPath, " " );
843 assertEquals( "lib/org/apache/dummy/dummy1/1.0.1/dummy1-1.0.jar", classPathEntries[0] );
844 assertEquals( "lib/org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
845 assertEquals( "lib/org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
846 }
847
848 @Test
849 public void shouldCreateArchiveCustomLayoutRepositoryNonUnique()
850 throws Exception
851 {
852 MavenSession session = getDummySession();
853 MavenProject project = getDummyProject();
854 File jarFile = new File( "target/test/dummy-custom-layout-repo-non-unique.jar" );
855 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
856
857 MavenArchiver archiver = getMavenArchiver( jarArchiver );
858
859 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
860 config.setForced( true );
861 config.getManifest().setAddDefaultImplementationEntries( true );
862 config.getManifest().setAddDefaultSpecificationEntries( true );
863 config.getManifest().setMainClass( "org.apache.maven.Foo" );
864 config.getManifest().setAddClasspath( true );
865 config.getManifest().setClasspathPrefix( "lib" );
866 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
867 config.getManifest().setCustomClasspathLayout( MavenArchiver.REPOSITORY_LAYOUT_NONUNIQUE );
868
869 archiver.createArchive( session, project, config );
870 assertTrue( jarFile.exists() );
871 Manifest manifest = archiver.getManifest( session, project, config );
872 String[] classPathEntries =
873 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
874 assertEquals( "lib/org/apache/dummy/dummy1/1.0.1/dummy1-1.0.1.jar", classPathEntries[0] );
875 assertEquals( "lib/org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
876 assertEquals( "lib/org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
877
878 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
879
880 assertNotNull( classPath );
881 classPathEntries = StringUtils.split( classPath, " " );
882 assertEquals( "lib/org/apache/dummy/dummy1/1.0.1/dummy1-1.0.1.jar", classPathEntries[0] );
883 assertEquals( "lib/org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
884 assertEquals( "lib/org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
885 }
886
887 @Test
888 public void shouldCreateArchiveWithSimpleClassPathLayoutUsingDefaults()
889 throws Exception
890 {
891 MavenSession session = getDummySession();
892 MavenProject project = getDummyProject();
893 File jarFile = new File( "target/test/dummy-defaults.jar" );
894 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
895
896 MavenArchiver archiver = getMavenArchiver( jarArchiver );
897
898 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
899 config.setForced( true );
900 config.getManifest().setAddDefaultImplementationEntries( true );
901 config.getManifest().setAddDefaultSpecificationEntries( true );
902 config.getManifest().setMainClass( "org.apache.maven.Foo" );
903 config.getManifest().setAddClasspath( true );
904 config.getManifest().setClasspathPrefix( "lib" );
905
906 archiver.createArchive( session, project, config );
907 assertTrue( jarFile.exists() );
908 Manifest manifest = archiver.getManifest( session, project, config );
909 String[] classPathEntries =
910 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
911 assertEquals( "lib/dummy1-1.0.jar", classPathEntries[0] );
912 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
913 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
914
915 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
916 assertNotNull( classPath );
917 classPathEntries = StringUtils.split( classPath, " " );
918 assertEquals( "lib/dummy1-1.0.jar", classPathEntries[0] );
919 assertEquals( "lib/dummy2-1.5.jar", classPathEntries[1] );
920 assertEquals( "lib/dummy3-2.0.jar", classPathEntries[2] );
921 }
922
923 @Test
924 public void testMavenRepoClassPathValue_WithSnapshot()
925 throws Exception
926 {
927 MavenSession session = getDummySession();
928 MavenProject project = getDummyProjectWithSnapshot();
929 File jarFile = new File( "target/test/dummy.jar" );
930 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
931
932 MavenArchiver archiver = getMavenArchiver( jarArchiver );
933
934 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
935 config.setForced( true );
936 config.getManifest().setAddDefaultImplementationEntries( true );
937 config.getManifest().setAddDefaultSpecificationEntries( true );
938 config.getManifest().setMainClass( "org.apache.maven.Foo" );
939 config.getManifest().setAddClasspath( true );
940 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_REPOSITORY );
941 archiver.createArchive( session, project, config );
942 assertTrue( jarFile.exists() );
943
944 Manifest manifest = archiver.getManifest( session, project, config );
945 String[] classPathEntries =
946 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
947 assertEquals( "org/apache/dummy/dummy1/1.1-SNAPSHOT/dummy1-1.1-20081022.112233-1.jar", classPathEntries[0] );
948 assertEquals( "org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
949 assertEquals( "org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
950
951 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
952 assertNotNull( classPath );
953 classPathEntries = StringUtils.split( classPath, " " );
954 assertEquals( "org/apache/dummy/dummy1/1.1-SNAPSHOT/dummy1-1.1-20081022.112233-1.jar", classPathEntries[0] );
955 assertEquals( "org/apache/dummy/foo/dummy2/1.5/dummy2-1.5.jar", classPathEntries[1] );
956 assertEquals( "org/apache/dummy/bar/dummy3/2.0/dummy3-2.0.jar", classPathEntries[2] );
957 }
958
959 @Test
960 public void testCustomClassPathValue()
961 throws Exception
962 {
963 MavenSession session = getDummySession();
964 MavenProject project = getDummyProject();
965 File jarFile = new File( "target/test/dummy.jar" );
966 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
967
968 MavenArchiver archiver = getMavenArchiver( jarArchiver );
969
970 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
971 config.setForced( true );
972 config.getManifest().setAddDefaultImplementationEntries( true );
973 config.getManifest().setAddDefaultSpecificationEntries( true );
974 config.getManifest().setMainClass( "org.apache.maven.Foo" );
975 config.getManifest().setAddClasspath( true );
976 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
977 config.getManifest().setCustomClasspathLayout( "${artifact.groupIdPath}/${artifact.artifactId}/${artifact.version}/TEST-${artifact.artifactId}-${artifact.version}${dashClassifier?}.${artifact.extension}" );
978 archiver.createArchive( session, project, config );
979 assertTrue( jarFile.exists() );
980 Manifest manifest = archiver.getManifest( session, project, config );
981 String[] classPathEntries =
982 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
983 assertEquals( "org/apache/dummy/dummy1/1.0/TEST-dummy1-1.0.jar", classPathEntries[0] );
984 assertEquals( "org/apache/dummy/foo/dummy2/1.5/TEST-dummy2-1.5.jar", classPathEntries[1] );
985 assertEquals( "org/apache/dummy/bar/dummy3/2.0/TEST-dummy3-2.0.jar", classPathEntries[2] );
986
987 final Manifest manifest1 = getJarFileManifest( jarFile );
988 String classPath = manifest1.getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
989 assertNotNull( classPath );
990 classPathEntries = StringUtils.split( classPath, " " );
991 assertEquals( "org/apache/dummy/dummy1/1.0/TEST-dummy1-1.0.jar", classPathEntries[0] );
992 assertEquals( "org/apache/dummy/foo/dummy2/1.5/TEST-dummy2-1.5.jar", classPathEntries[1] );
993 assertEquals( "org/apache/dummy/bar/dummy3/2.0/TEST-dummy3-2.0.jar", classPathEntries[2] );
994 }
995
996 @Test
997 public void testCustomClassPathValue_WithSnapshotResolvedVersion()
998 throws Exception
999 {
1000 MavenSession session = getDummySession();
1001 MavenProject project = getDummyProjectWithSnapshot();
1002 File jarFile = new File( "target/test/dummy.jar" );
1003 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
1004 MavenArchiver archiver = getMavenArchiver( jarArchiver );
1005
1006 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
1007 config.setForced( true );
1008 config.getManifest().setAddDefaultImplementationEntries( true );
1009 config.getManifest().setAddDefaultSpecificationEntries( true );
1010 config.getManifest().setMainClass( "org.apache.maven.Foo" );
1011 config.getManifest().setAddClasspath( true );
1012 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
1013 config.getManifest().setCustomClasspathLayout( "${artifact.groupIdPath}/${artifact.artifactId}/${artifact.baseVersion}/TEST-${artifact.artifactId}-${artifact.version}${dashClassifier?}.${artifact.extension}" );
1014 archiver.createArchive( session, project, config );
1015 assertTrue( jarFile.exists() );
1016
1017 Manifest manifest = archiver.getManifest( session, project, config );
1018 String[] classPathEntries =
1019 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
1020 assertEquals( "org/apache/dummy/dummy1/1.1-SNAPSHOT/TEST-dummy1-1.1-20081022.112233-1.jar",
1021 classPathEntries[0] );
1022 assertEquals( "org/apache/dummy/foo/dummy2/1.5/TEST-dummy2-1.5.jar", classPathEntries[1] );
1023 assertEquals( "org/apache/dummy/bar/dummy3/2.0/TEST-dummy3-2.0.jar", classPathEntries[2] );
1024
1025 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
1026 assertNotNull( classPath );
1027 classPathEntries = StringUtils.split( classPath, " " );
1028 assertEquals( "org/apache/dummy/dummy1/1.1-SNAPSHOT/TEST-dummy1-1.1-20081022.112233-1.jar",
1029 classPathEntries[0] );
1030 assertEquals( "org/apache/dummy/foo/dummy2/1.5/TEST-dummy2-1.5.jar", classPathEntries[1] );
1031 assertEquals( "org/apache/dummy/bar/dummy3/2.0/TEST-dummy3-2.0.jar", classPathEntries[2] );
1032 }
1033
1034 @Test
1035 public void testCustomClassPathValue_WithSnapshotForcingBaseVersion()
1036 throws Exception
1037 {
1038 MavenSession session = getDummySession();
1039 MavenProject project = getDummyProjectWithSnapshot();
1040 File jarFile = new File( "target/test/dummy.jar" );
1041 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
1042
1043 MavenArchiver archiver = getMavenArchiver( jarArchiver );
1044
1045 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
1046 config.setForced( true );
1047 config.getManifest().setAddDefaultImplementationEntries( true );
1048 config.getManifest().setAddDefaultSpecificationEntries( true );
1049 config.getManifest().setMainClass( "org.apache.maven.Foo" );
1050 config.getManifest().setAddClasspath( true );
1051 config.getManifest().setClasspathLayoutType( ManifestConfiguration.CLASSPATH_LAYOUT_TYPE_CUSTOM );
1052 config.getManifest().setCustomClasspathLayout( "${artifact.groupIdPath}/${artifact.artifactId}/${artifact.baseVersion}/TEST-${artifact.artifactId}-${artifact.baseVersion}${dashClassifier?}.${artifact.extension}" );
1053 archiver.createArchive( session, project, config );
1054 assertTrue( jarFile.exists() );
1055 Manifest manifest = archiver.getManifest( session, project, config );
1056 String[] classPathEntries =
1057 StringUtils.split( new String( manifest.getMainAttributes().getValue( "Class-Path" ).getBytes() ), " " );
1058 assertEquals( "org/apache/dummy/dummy1/1.1-SNAPSHOT/TEST-dummy1-1.1-SNAPSHOT.jar", classPathEntries[0] );
1059 assertEquals( "org/apache/dummy/foo/dummy2/1.5/TEST-dummy2-1.5.jar", classPathEntries[1] );
1060 assertEquals( "org/apache/dummy/bar/dummy3/2.0/TEST-dummy3-2.0.jar", classPathEntries[2] );
1061
1062 String classPath = getJarFileManifest( jarFile ).getMainAttributes().getValue( Attributes.Name.CLASS_PATH );
1063 assertNotNull( classPath );
1064 classPathEntries = StringUtils.split( classPath, " " );
1065 assertEquals( "org/apache/dummy/dummy1/1.1-SNAPSHOT/TEST-dummy1-1.1-SNAPSHOT.jar", classPathEntries[0] );
1066 assertEquals( "org/apache/dummy/foo/dummy2/1.5/TEST-dummy2-1.5.jar", classPathEntries[1] );
1067 assertEquals( "org/apache/dummy/bar/dummy3/2.0/TEST-dummy3-2.0.jar", classPathEntries[2] );
1068 }
1069
1070 @Test
1071 public void testDefaultPomProperties()
1072 throws Exception
1073 {
1074 MavenSession session = getDummySession();
1075 MavenProject project = getDummyProject();
1076 File jarFile = new File( "target/test/dummy.jar" );
1077 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
1078
1079 MavenArchiver archiver = getMavenArchiver( jarArchiver );
1080
1081 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
1082 config.setForced( true );
1083 archiver.createArchive( session, project, config );
1084 assertTrue( jarFile.exists() );
1085
1086 final String groupId = project.getGroupId();
1087 final String artifactId = project.getArtifactId();
1088 final String version = project.getVersion();
1089
1090 JarFile virtJarFile = new JarFile( jarFile );
1091 ZipEntry pomPropertiesEntry =
1092 virtJarFile.getEntry( "META-INF/maven/" + groupId + "/" + artifactId + "/pom.properties" );
1093 assertNotNull( pomPropertiesEntry );
1094
1095 InputStream is = virtJarFile.getInputStream( pomPropertiesEntry );
1096 Properties p = loadProperties( is );
1097
1098 assertEquals( groupId, p.getProperty( "groupId" ) );
1099 assertEquals( artifactId, p.getProperty( "artifactId" ) );
1100 assertEquals( version, p.getProperty( "version" ) );
1101
1102 virtJarFile.close();
1103 }
1104
1105 @Test
1106 public void testCustomPomProperties()
1107 throws Exception
1108 {
1109 MavenSession session = getDummySession();
1110 MavenProject project = getDummyProject();
1111 File jarFile = new File( "target/test/dummy.jar" );
1112 JarArchiver jarArchiver = getCleanJarArchiver( jarFile );
1113
1114 MavenArchiver archiver = getMavenArchiver( jarArchiver );
1115
1116 File customPomPropertiesFile = new File( "src/test/resources/custom-pom.properties" );
1117 MavenArchiveConfiguration config = new MavenArchiveConfiguration();
1118 config.setForced( true );
1119 config.setPomPropertiesFile( customPomPropertiesFile );
1120 archiver.createArchive( session, project, config );
1121 assertTrue( jarFile.exists() );
1122
1123 final String groupId = project.getGroupId();
1124 final String artifactId = project.getArtifactId();
1125 final String version = project.getVersion();
1126
1127 JarFile virtJarFile = new JarFile( jarFile );
1128 ZipEntry pomPropertiesEntry =
1129 virtJarFile.getEntry( "META-INF/maven/" + groupId + "/" + artifactId + "/pom.properties" );
1130 assertNotNull( pomPropertiesEntry );
1131
1132 InputStream is = virtJarFile.getInputStream( pomPropertiesEntry );
1133 Properties p = loadProperties( is );
1134
1135 assertEquals( groupId, p.getProperty( "groupId" ) );
1136 assertEquals( artifactId, p.getProperty( "artifactId" ) );
1137 assertEquals( version, p.getProperty( "version" ) );
1138 assertEquals( "1337", p.getProperty( "build.revision" ) );
1139 assertEquals( "tags/0.1.1", p.getProperty( "build.branch" ) );
1140
1141 virtJarFile.close();
1142 }
1143
1144 private JarArchiver getCleanJarArchiver( File jarFile )
1145 {
1146 deleteAndAssertNotPresent( jarFile );
1147 JarArchiver jarArchiver = new JarArchiver();
1148 jarArchiver.setDestFile( jarFile );
1149 return jarArchiver;
1150 }
1151
1152
1153
1154
1155
1156 private MavenProject getDummyProject()
1157 {
1158 MavenProject project = getMavenProject();
1159 File pomFile = new File( "src/test/resources/pom.xml" );
1160 pomFile.setLastModified( System.currentTimeMillis() - 60000L );
1161 project.setFile( pomFile );
1162 Build build = new Build();
1163 build.setDirectory( "target" );
1164 build.setOutputDirectory( "target" );
1165 project.setBuild( build );
1166 project.setName( "archiver test" );
1167 project.setUrl( "http://maven.apache.org" );
1168 Organization organization = new Organization();
1169 organization.setName( "Apache" );
1170 project.setOrganization( organization );
1171 MockArtifact artifact = new MockArtifact();
1172 artifact.setGroupId( "org.apache.dummy" );
1173 artifact.setArtifactId( "dummy" );
1174 artifact.setVersion( "0.1.1" );
1175 artifact.setBaseVersion( "0.1.2" );
1176 artifact.setType( "jar" );
1177 artifact.setArtifactHandler( new DefaultArtifactHandler( "jar" ) );
1178 project.setArtifact( artifact );
1179
1180 Set<Artifact> artifacts = getArtifacts( getMockArtifact1Release(), getMockArtifact2(), getMockArtifact3() );
1181 project.setArtifacts( artifacts );
1182
1183 return project;
1184 }
1185
1186 private MavenProject getMavenProject()
1187 {
1188 Model model = new Model();
1189 model.setGroupId( "org.apache.dummy" );
1190 model.setArtifactId( "dummy" );
1191 model.setVersion( "0.1.1" );
1192
1193 final MavenProject project = new MavenProject( model );
1194 project.setExtensionArtifacts( Collections.<Artifact>emptySet() );
1195 project.setRemoteArtifactRepositories( Collections.<ArtifactRepository>emptyList() );
1196 project.setPluginArtifactRepositories( Collections.<ArtifactRepository>emptyList() );
1197 return project;
1198 }
1199
1200 private MockArtifact getMockArtifact3()
1201 {
1202 MockArtifact artifact3 = new MockArtifact();
1203 artifact3.setGroupId( "org.apache.dummy.bar" );
1204 artifact3.setArtifactId( "dummy3" );
1205 artifact3.setVersion( "2.0" );
1206 artifact3.setScope( "runtime" );
1207 artifact3.setType( "jar" );
1208 artifact3.setFile( getClasspathFile( artifact3.getArtifactId() + "-" + artifact3.getVersion() + ".jar" ) );
1209 return artifact3;
1210 }
1211
1212 private MavenProject getDummyProjectWithSnapshot()
1213 {
1214 MavenProject project = getMavenProject();
1215 File pomFile = new File( "src/test/resources/pom.xml" );
1216 pomFile.setLastModified( System.currentTimeMillis() - 60000L );
1217 project.setFile( pomFile );
1218 Build build = new Build();
1219 build.setDirectory( "target" );
1220 build.setOutputDirectory( "target" );
1221 project.setBuild( build );
1222 project.setName( "archiver test" );
1223 Organization organization = new Organization();
1224 organization.setName( "Apache" );
1225 project.setOrganization( organization );
1226
1227 MockArtifact artifact = new MockArtifact();
1228 artifact.setGroupId( "org.apache.dummy" );
1229 artifact.setArtifactId( "dummy" );
1230 artifact.setVersion( "0.1.1" );
1231 artifact.setBaseVersion( "0.1.1" );
1232 artifact.setType( "jar" );
1233 artifact.setArtifactHandler( new DefaultArtifactHandler( "jar" ) );
1234 project.setArtifact( artifact );
1235
1236 Set<Artifact> artifacts = getArtifacts( getMockArtifact1(), getMockArtifact2(), getMockArtifact3() );
1237
1238 project.setArtifacts( artifacts );
1239
1240 return project;
1241 }
1242
1243 private ArtifactHandler getMockArtifactHandler()
1244 {
1245 return new ArtifactHandler()
1246 {
1247
1248 public String getClassifier()
1249 {
1250 return null;
1251 }
1252
1253 public String getDirectory()
1254 {
1255 return null;
1256 }
1257
1258 public String getExtension()
1259 {
1260 return "jar";
1261 }
1262
1263 public String getLanguage()
1264 {
1265 return null;
1266 }
1267
1268 public String getPackaging()
1269 {
1270 return null;
1271 }
1272
1273 public boolean isAddedToClasspath()
1274 {
1275 return true;
1276 }
1277
1278 public boolean isIncludesDependencies()
1279 {
1280 return false;
1281 }
1282
1283 };
1284 }
1285
1286 private MockArtifact getMockArtifact2()
1287 {
1288 MockArtifact artifact2 = new MockArtifact();
1289 artifact2.setGroupId( "org.apache.dummy.foo" );
1290 artifact2.setArtifactId( "dummy2" );
1291 artifact2.setVersion( "1.5" );
1292 artifact2.setType( "jar" );
1293 artifact2.setScope( "runtime" );
1294 artifact2.setFile( getClasspathFile( artifact2.getArtifactId() + "-" + artifact2.getVersion() + ".jar" ) );
1295 return artifact2;
1296 }
1297
1298 private MockArtifact getArtifactWithDot()
1299 {
1300 MockArtifact artifact2 = new MockArtifact();
1301 artifact2.setGroupId( "org.apache.dummy.foo" );
1302 artifact2.setArtifactId( "dummy.dot" );
1303 artifact2.setVersion( "1.5" );
1304 artifact2.setType( "jar" );
1305 artifact2.setScope( "runtime" );
1306 artifact2.setFile( getClasspathFile( artifact2.getArtifactId() + "-" + artifact2.getVersion() + ".jar" ) );
1307 return artifact2;
1308 }
1309
1310 private MockArtifact getMockArtifact1()
1311 {
1312 MockArtifact artifact1 = new MockArtifact();
1313 artifact1.setGroupId( "org.apache.dummy" );
1314 artifact1.setArtifactId( "dummy1" );
1315 artifact1.setSnapshotVersion( "1.1-20081022.112233-1", "1.1-SNAPSHOT" );
1316 artifact1.setType( "jar" );
1317 artifact1.setScope( "runtime" );
1318 artifact1.setFile( getClasspathFile( artifact1.getArtifactId() + "-" + artifact1.getVersion() + ".jar" ) );
1319 return artifact1;
1320 }
1321
1322 private MockArtifact getMockArtifact1Release()
1323 {
1324 MockArtifact artifact1 = new MockArtifact();
1325 artifact1.setGroupId( "org.apache.dummy" );
1326 artifact1.setArtifactId( "dummy1" );
1327 artifact1.setVersion( "1.0" );
1328 artifact1.setBaseVersion( "1.0.1" );
1329 artifact1.setType( "jar" );
1330 artifact1.setScope( "runtime" );
1331 artifact1.setFile( getClasspathFile( artifact1.getArtifactId() + "-" + artifact1.getVersion() + ".jar" ) );
1332 return artifact1;
1333 }
1334
1335 private File getClasspathFile( String file )
1336 {
1337 URL resource = Thread.currentThread().getContextClassLoader().getResource( file );
1338 if ( resource == null )
1339 {
1340 fail("Cannot retrieve java.net.URL for file: " + file + " on the current test classpath." );
1341 }
1342
1343 URI uri = new File( resource.getPath() ).toURI().normalize();
1344
1345 return new File( uri.getPath().replaceAll( "%20", " " ) );
1346 }
1347
1348 private MavenSession getDummySession()
1349 {
1350 Properties systemProperties = new Properties();
1351 systemProperties.put( "maven.version", "3.0.4" );
1352
1353 return getDummySession( systemProperties );
1354 }
1355
1356 private MavenSession getDummySessionWithoutMavenVersion()
1357 {
1358 return getDummySession( new Properties() );
1359 }
1360
1361 private MavenSession getDummySession( Properties systemProperties )
1362 {
1363 PlexusContainer container = null;
1364 File settings = null;
1365 List<String> goals = null;
1366 Date startTime = new Date();
1367
1368 MavenExecutionRequest request = new DefaultMavenExecutionRequest();
1369 request.setSystemProperties( systemProperties );
1370 request.setGoals( goals );
1371 request.setStartTime( startTime );
1372 request.setUserSettingsFile( settings );
1373
1374 MavenExecutionResult result = new DefaultMavenExecutionResult();
1375
1376 RepositorySystemSession rss = new DefaultRepositorySystemSession();
1377
1378 return new MavenSession( container, rss, request, result );
1379
1380 }
1381
1382 private Set<Artifact> getArtifacts( Artifact... artifacts )
1383 {
1384 final ArtifactHandler mockArtifactHandler = getMockArtifactHandler();
1385 Set<Artifact> result = new TreeSet<Artifact>( new ArtifactComparator() );
1386 for ( Artifact artifact : artifacts )
1387 {
1388 artifact.setArtifactHandler( mockArtifactHandler );
1389 result.add( artifact );
1390 }
1391 return result;
1392 }
1393
1394 private Properties loadProperties( InputStream is )
1395 throws IOException
1396 {
1397 Properties p = new Properties();
1398 try
1399 {
1400 p.load( is );
1401 is.close();
1402 is = null;
1403 return p;
1404 }
1405 finally
1406 {
1407 IOUtil.close( is );
1408 }
1409 }
1410
1411 public Manifest getJarFileManifest( File jarFile )
1412 throws IOException
1413 {
1414 JarFile jar = null;
1415 try
1416 {
1417 jar = new JarFile( jarFile );
1418 return jar.getManifest();
1419 }
1420 finally
1421 {
1422 if ( jar != null )
1423 {
1424 jar.close();
1425 }
1426 }
1427
1428 }
1429 }