1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.plugins.assembly.archive.phase;
20
21 import java.io.File;
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.Collections;
25 import java.util.HashSet;
26 import java.util.LinkedHashMap;
27 import java.util.List;
28 import java.util.Set;
29
30 import org.apache.maven.artifact.Artifact;
31 import org.apache.maven.model.Model;
32 import org.apache.maven.plugins.assembly.AssemblerConfigurationSource;
33 import org.apache.maven.plugins.assembly.InvalidAssemblerConfigurationException;
34 import org.apache.maven.plugins.assembly.archive.ArchiveCreationException;
35 import org.apache.maven.plugins.assembly.archive.DefaultAssemblyArchiverTest;
36 import org.apache.maven.plugins.assembly.artifact.DependencyResolver;
37 import org.apache.maven.plugins.assembly.model.Assembly;
38 import org.apache.maven.plugins.assembly.model.FileSet;
39 import org.apache.maven.plugins.assembly.model.ModuleBinaries;
40 import org.apache.maven.plugins.assembly.model.ModuleSet;
41 import org.apache.maven.plugins.assembly.model.ModuleSources;
42 import org.apache.maven.project.MavenProject;
43 import org.apache.maven.project.ProjectBuilder;
44 import org.codehaus.plexus.archiver.Archiver;
45 import org.junit.Before;
46 import org.junit.Rule;
47 import org.junit.Test;
48 import org.junit.rules.TemporaryFolder;
49 import org.junit.runner.RunWith;
50 import org.mockito.junit.MockitoJUnitRunner;
51 import org.slf4j.Logger;
52 import org.slf4j.LoggerFactory;
53
54 import static java.util.Collections.singleton;
55 import static org.junit.Assert.assertEquals;
56 import static org.junit.Assert.assertFalse;
57 import static org.junit.Assert.assertTrue;
58 import static org.junit.Assert.fail;
59 import static org.mockito.Mockito.*;
60
61 @RunWith(MockitoJUnitRunner.class)
62 public class ModuleSetAssemblyPhaseTest {
63 private final Logger logger = LoggerFactory.getLogger(getClass());
64
65 @Rule
66 public TemporaryFolder temporaryFolder = new TemporaryFolder();
67
68 private ModuleSetAssemblyPhase phase;
69
70 private DependencyResolver dependencyResolver;
71
72 @Before
73 public void setUp() {
74 ProjectBuilder projectBuilder = mock(ProjectBuilder.class);
75 this.dependencyResolver = mock(DependencyResolver.class);
76
77 this.phase = new ModuleSetAssemblyPhase(projectBuilder, dependencyResolver);
78 }
79
80 @Test
81 public void testIsDeprecatedModuleSourcesConfigPresent_ShouldCatchOutputDir() {
82 final ModuleSources sources = new ModuleSources();
83 sources.setOutputDirectory("outdir");
84
85 assertTrue(this.phase.isDeprecatedModuleSourcesConfigPresent(sources));
86 }
87
88 @Test
89 public void testIsDeprecatedModuleSourcesConfigPresent_ShouldCatchInclude() {
90 final ModuleSources sources = new ModuleSources();
91 sources.addInclude("**/included.txt");
92
93 assertTrue(this.phase.isDeprecatedModuleSourcesConfigPresent(sources));
94 }
95
96 @Test
97 public void testIsDeprecatedModuleSourcesConfigPresent_ShouldCatchExclude() {
98 final ModuleSources sources = new ModuleSources();
99 sources.addExclude("**/excluded.txt");
100
101 assertTrue(this.phase.isDeprecatedModuleSourcesConfigPresent(sources));
102 }
103
104 @Test
105 public void testIsDeprecatedModuleSourcesConfigPresent_ShouldNotCatchFileMode() {
106 final ModuleSources sources = new ModuleSources();
107 sources.setFileMode("777");
108
109 assertFalse(this.phase.isDeprecatedModuleSourcesConfigPresent(sources));
110 }
111
112 @Test
113 public void testIsDeprecatedModuleSourcesConfigPresent_ShouldNotCatchDirMode() {
114 final ModuleSources sources = new ModuleSources();
115 sources.setDirectoryMode("777");
116
117 assertFalse(this.phase.isDeprecatedModuleSourcesConfigPresent(sources));
118 }
119
120 @Test
121 public void testCreateFileSet_ShouldUseModuleDirOnlyWhenOutDirIsNull() throws Exception {
122 final Model model = new Model();
123 model.setArtifactId("artifact");
124
125 final MavenProject project = new MavenProject(model);
126
127 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
128 when(configSource.getProject()).thenReturn(project);
129
130 final FileSet fs = new FileSet();
131
132 final ModuleSources sources = new ModuleSources();
133 sources.setIncludeModuleDirectory(true);
134
135 final File basedir = temporaryFolder.getRoot();
136
137 final MavenProject artifactProject = new MavenProject(new Model());
138 artifactProject.setGroupId("GROUPID");
139 artifactProject.setFile(new File(basedir, "pom.xml"));
140
141 Artifact artifact = mock(Artifact.class);
142 when(artifact.getGroupId()).thenReturn("GROUPID");
143 when(artifact.getArtifactId()).thenReturn("artifact");
144
145 artifactProject.setArtifact(artifact);
146
147 DefaultAssemblyArchiverTest.setupInterpolators(configSource, project);
148
149 final FileSet result = this.phase.createFileSet(fs, sources, artifactProject, configSource);
150
151 assertEquals("artifact/", result.getOutputDirectory());
152
153
154 verify(configSource, atLeastOnce()).getFinalName();
155 verify(configSource, atLeastOnce()).getMavenSession();
156 verify(configSource, atLeastOnce()).getProject();
157 }
158
159 @Test
160 public void testCreateFileSet_ShouldPrependModuleDirWhenOutDirIsProvided() throws Exception {
161 final Model model = new Model();
162 model.setArtifactId("artifact");
163
164 final MavenProject project = new MavenProject(model);
165
166 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
167 when(configSource.getProject()).thenReturn(project);
168
169 final FileSet fs = new FileSet();
170 fs.setOutputDirectory("out");
171
172 final ModuleSources sources = new ModuleSources();
173 sources.setIncludeModuleDirectory(true);
174
175 final MavenProject artifactProject = new MavenProject(new Model());
176 artifactProject.setGroupId("GROUPID");
177
178 final File basedir = temporaryFolder.getRoot();
179
180 artifactProject.setFile(new File(basedir, "pom.xml"));
181
182 Artifact artifact = mock(Artifact.class);
183 when(artifact.getGroupId()).thenReturn("GROUPID");
184 when(artifact.getArtifactId()).thenReturn("artifact");
185
186 artifactProject.setArtifact(artifact);
187 DefaultAssemblyArchiverTest.setupInterpolators(configSource, project );
188
189 final FileSet result = this.phase.createFileSet(fs, sources, artifactProject, configSource);
190
191 assertEquals("artifact/out/", result.getOutputDirectory());
192
193
194 verify(configSource, atLeastOnce()).getFinalName();
195 verify(configSource, atLeastOnce()).getMavenSession();
196 verify(configSource, atLeastOnce()).getProject();
197 }
198
199 @Test
200 public void testCreateFileSet_ShouldAddExcludesForSubModulesWhenExcludeSubModDirsIsTrue() throws Exception {
201 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
202
203 final FileSet fs = new FileSet();
204
205 final ModuleSources sources = new ModuleSources();
206 sources.setExcludeSubModuleDirectories(true);
207
208 final Model model = new Model();
209 model.setArtifactId("artifact");
210
211 model.addModule("submodule");
212
213 final MavenProject project = new MavenProject(model);
214
215 final File basedir = temporaryFolder.getRoot();
216 project.setGroupId("GROUPID");
217 project.setFile(new File(basedir, "pom.xml"));
218
219 Artifact artifact = mock(Artifact.class);
220 when(artifact.getGroupId()).thenReturn("GROUPID");
221
222 project.setArtifact(artifact);
223 DefaultAssemblyArchiverTest.setupInterpolators(configSource, project);
224
225 final FileSet result = this.phase.createFileSet(fs, sources, project, configSource);
226
227 assertEquals(1, result.getExcludes().size());
228 assertEquals("submodule/**", result.getExcludes().get(0));
229
230
231 verify(configSource, atLeastOnce()).getFinalName();
232 verify(configSource, atLeastOnce()).getMavenSession();
233 verify(configSource, atLeastOnce()).getProject();
234 }
235
236 @Test
237 public void testExecute_ShouldSkipIfNoModuleSetsFound() throws Exception {
238 final Assembly assembly = new Assembly();
239 assembly.setIncludeBaseDirectory(false);
240
241 this.phase.execute(assembly, null, null);
242 }
243
244 @Test
245 public void testExecute_ShouldAddOneModuleSetWithOneModuleInIt() throws Exception {
246 final MavenProject project = createProject("group", "artifact", "version", null);
247
248 final MavenProject module = createProject("group", "module", "version", project);
249
250 Artifact artifact = mock(Artifact.class);
251 final File moduleArtifactFile = temporaryFolder.newFile();
252 when(artifact.getGroupId()).thenReturn("GROUPID");
253 when(artifact.getFile()).thenReturn(moduleArtifactFile);
254 module.setArtifact(artifact);
255
256 final List<MavenProject> projects = new ArrayList<>();
257 projects.add(module);
258
259 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
260 when(configSource.getReactorProjects()).thenReturn(projects);
261 when(configSource.getFinalName()).thenReturn("final-name");
262 when(configSource.getProject()).thenReturn(project);
263
264 final Archiver archiver = mock(Archiver.class);
265 when(archiver.getDestFile()).thenReturn(new File("junk"));
266 when(archiver.getOverrideDirectoryMode()).thenReturn(0777);
267 when(archiver.getOverrideFileMode()).thenReturn(0777);
268
269 final ModuleBinaries bin = new ModuleBinaries();
270 bin.setOutputFileNameMapping("artifact");
271 bin.setOutputDirectory("out");
272 bin.setFileMode("777");
273 bin.setUnpack(false);
274 bin.setIncludeDependencies(false);
275
276 final ModuleSet ms = new ModuleSet();
277 ms.setBinaries(bin);
278
279 final Assembly assembly = new Assembly();
280 assembly.setIncludeBaseDirectory(false);
281 assembly.addModuleSet(ms);
282
283 when(dependencyResolver.resolveDependencySets(eq(assembly), eq(ms), eq(configSource), anyList()))
284 .thenReturn(new LinkedHashMap<>());
285 DefaultAssemblyArchiverTest.setupInterpolators(configSource, module);
286
287 this.phase.execute(assembly, archiver, configSource);
288
289
290 verify(configSource, atLeastOnce()).getFinalName();
291 verify(configSource, atLeastOnce()).getMavenSession();
292 verify(configSource, atLeastOnce()).getProject();
293 verify(configSource, atLeastOnce()).getReactorProjects();
294
295 verify(archiver).addFile(moduleArtifactFile, "out/artifact", 511);
296 verify(archiver, atLeastOnce()).getDestFile();
297 verify(archiver).getOverrideDirectoryMode();
298 verify(archiver).getOverrideFileMode();
299 verify(archiver, times(2)).setFileMode(511);
300
301 verify(dependencyResolver).resolveDependencySets(eq(assembly), eq(ms), eq(configSource), anyList());
302 }
303
304 @Test
305 public void testAddModuleBinaries_ShouldReturnImmediatelyWhenBinariesIsNull() throws Exception {
306 this.phase.addModuleBinaries(null, null, null, null, null, null);
307 }
308
309 @Test
310 public void testAddModuleBinaries_ShouldFilterPomModule() throws Exception {
311 final ModuleBinaries binaries = new ModuleBinaries();
312
313 binaries.setUnpack(false);
314 binaries.setFileMode("777");
315 binaries.setOutputDirectory("out");
316 binaries.setOutputFileNameMapping("artifact");
317
318 final MavenProject project = createProject("group", "artifact", "version", null);
319 project.setPackaging("pom");
320
321 Artifact artifact = mock(Artifact.class);
322 project.setArtifact(artifact);
323
324 final Set<MavenProject> projects = singleton(project);
325
326 this.phase.addModuleBinaries(null, null, binaries, projects, null, null);
327 }
328
329 @Test
330 public void testAddModuleBinaries_ShouldAddOneModuleAttachmentArtifactAndNoDeps() throws Exception {
331 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
332 when(configSource.getFinalName()).thenReturn("final-name");
333
334 Artifact artifact = mock(Artifact.class);
335 when(artifact.getGroupId()).thenReturn("GROUPID");
336 when(artifact.getClassifier()).thenReturn("test");
337 final File artifactFile = temporaryFolder.newFile();
338 when(artifact.getFile()).thenReturn(artifactFile);
339
340 final Archiver archiver = mock(Archiver.class);
341 when(archiver.getDestFile()).thenReturn(new File("junk"));
342 when(archiver.getOverrideDirectoryMode()).thenReturn(0222);
343 when(archiver.getOverrideFileMode()).thenReturn(0222);
344
345 final ModuleBinaries binaries = new ModuleBinaries();
346
347 binaries.setIncludeDependencies(false);
348 binaries.setUnpack(false);
349 binaries.setFileMode("777");
350 binaries.setOutputDirectory("out");
351 binaries.setOutputFileNameMapping("artifact");
352 binaries.setAttachmentClassifier("test");
353
354 final MavenProject project = createProject("group", "artifact", "version", null);
355 project.addAttachedArtifact(artifact);
356
357 final Set<MavenProject> projects = singleton(project);
358
359 when(dependencyResolver.resolveDependencySets(isNull(), isNull(), eq(configSource), anyList()))
360 .thenReturn(new LinkedHashMap<>());
361 DefaultAssemblyArchiverTest.setupInterpolators(configSource, project);
362
363 this.phase.addModuleBinaries(null, null, binaries, projects, archiver, configSource);
364
365
366 verify(configSource, atLeastOnce()).getFinalName();
367 verify(configSource, atLeastOnce()).getMavenSession();
368 verify(configSource, atLeastOnce()).getProject();
369
370 verify(archiver).addFile(artifactFile, "out/artifact", 511);
371 verify(archiver, atLeastOnce()).getDestFile();
372 verify(archiver).getOverrideDirectoryMode();
373 verify(archiver).getOverrideFileMode();
374 verify(archiver).setFileMode(511);
375 verify(archiver).setFileMode(146);
376
377 verify(dependencyResolver).resolveDependencySets(isNull(), isNull(), eq(configSource), anyList());
378 }
379
380 @Test
381 public void testAddModuleBinaries_ShouldFailWhenOneModuleDoesntHaveAttachmentWithMatchingClassifier()
382 throws Exception {
383 Artifact artifact = mock(Artifact.class);
384
385 final ModuleBinaries binaries = new ModuleBinaries();
386
387 binaries.setUnpack(false);
388 binaries.setFileMode("777");
389 binaries.setOutputDirectory("out");
390 binaries.setOutputFileNameMapping("artifact");
391 binaries.setAttachmentClassifier("test");
392
393 final MavenProject project = createProject("group", "artifact", "version", null);
394 project.setArtifact(artifact);
395
396 final Set<MavenProject> projects = singleton(project);
397
398 try {
399
400 this.phase.addModuleBinaries(null, null, binaries, projects, null, null);
401
402 fail("Should throw an invalid configuration exception because of module with missing attachment.");
403 } catch (final InvalidAssemblerConfigurationException e) {
404 assertEquals(
405 "Cannot find attachment with classifier: test in module project: group:artifact:jar:version. "
406 + "Please exclude this module from the module-set.",
407 e.getMessage());
408
409 }
410 }
411
412 @Test
413 public void testAddModuleBinaries_ShouldAddOneModuleArtifactAndNoDeps() throws Exception {
414 Artifact artifact = mock(Artifact.class);
415 final File artifactFile = temporaryFolder.newFile();
416 when(artifact.getGroupId()).thenReturn("GROUPID");
417 when(artifact.getFile()).thenReturn(artifactFile);
418
419 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
420 when(configSource.getFinalName()).thenReturn("final-name");
421
422 final Archiver archiver = mock(Archiver.class);
423 when(archiver.getDestFile()).thenReturn(new File("junk"));
424 when(archiver.getOverrideDirectoryMode()).thenReturn(0222);
425 when(archiver.getOverrideFileMode()).thenReturn(0222);
426
427 final ModuleBinaries binaries = new ModuleBinaries();
428
429 binaries.setIncludeDependencies(false);
430 binaries.setUnpack(false);
431 binaries.setFileMode("777");
432 binaries.setOutputDirectory("out");
433 binaries.setOutputFileNameMapping("artifact");
434
435 final MavenProject project = createProject("group", "artifact", "version", null);
436 project.setArtifact(artifact);
437
438 final Set<MavenProject> projects = singleton(project);
439
440 when(dependencyResolver.resolveDependencySets(
441 isNull(), isNull(), any(AssemblerConfigurationSource.class), anyList()))
442 .thenReturn(new LinkedHashMap<>());
443 DefaultAssemblyArchiverTest.setupInterpolators(configSource, project);
444
445 this.phase.addModuleBinaries(null, null, binaries, projects, archiver, configSource);
446
447
448 verify(configSource, atLeastOnce()).getFinalName();
449 verify(configSource, atLeastOnce()).getMavenSession();
450 verify(configSource, atLeastOnce()).getProject();
451
452 verify(dependencyResolver)
453 .resolveDependencySets(isNull(), isNull(), any(AssemblerConfigurationSource.class), anyList());
454
455 verify(archiver).addFile(artifactFile, "out/artifact", 511);
456 verify(archiver, atLeastOnce()).getDestFile();
457 verify(archiver).getOverrideDirectoryMode();
458 verify(archiver).getOverrideFileMode();
459 verify(archiver).setFileMode(511);
460 verify(archiver).setFileMode(146);
461 }
462
463 @Test
464 public void testAddModuleArtifact_ShouldThrowExceptionWhenArtifactFileIsNull() throws Exception {
465 Artifact artifact = mock(Artifact.class);
466 try {
467 this.phase.addModuleArtifact(artifact, null, null, null, null);
468
469 fail("Expected ArchiveCreationException since artifact file is null.");
470 } catch (final ArchiveCreationException e) {
471
472 }
473 }
474
475 @Test
476 public void testAddModuleArtifact_ShouldAddOneArtifact() throws Exception {
477 Artifact artifact = mock(Artifact.class);
478 when(artifact.getGroupId()).thenReturn("GROUPID");
479 final File artifactFile = temporaryFolder.newFile();
480 when(artifact.getFile()).thenReturn(artifactFile);
481
482 final MavenProject project = createProject("group", "artifact", "version", null);
483 project.setArtifact(artifact);
484
485 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
486 when(configSource.getFinalName()).thenReturn("final-name");
487
488 final Archiver archiver = mock(Archiver.class);
489 when(archiver.getDestFile()).thenReturn(new File("junk"));
490 when(archiver.getOverrideDirectoryMode()).thenReturn(0222);
491 when(archiver.getOverrideFileMode()).thenReturn(0222);
492
493 final ModuleBinaries binaries = new ModuleBinaries();
494 binaries.setOutputDirectory("out");
495 binaries.setOutputFileNameMapping("artifact");
496 binaries.setUnpack(false);
497 binaries.setFileMode("777");
498 DefaultAssemblyArchiverTest.setupInterpolators(configSource, project);
499
500 this.phase.addModuleArtifact(artifact, project, archiver, configSource, binaries);
501
502
503 verify(configSource, atLeastOnce()).getFinalName();
504 verify(configSource, atLeastOnce()).getMavenSession();
505 verify(configSource, atLeastOnce()).getProject();
506
507 verify(archiver).addFile(artifactFile, "out/artifact", 511);
508 verify(archiver, atLeastOnce()).getDestFile();
509 verify(archiver).getOverrideDirectoryMode();
510 verify(archiver).getOverrideFileMode();
511 verify(archiver).setFileMode(511);
512 verify(archiver).setFileMode(146);
513 }
514
515 @Test
516 public void testAddModuleSourceFileSets_ShouldReturnImmediatelyIfSourcesIsNull() throws Exception {
517 this.phase.addModuleSourceFileSets(null, null, null, null);
518 }
519
520 @Test
521 public void testAddModuleSourceFileSets_ShouldAddOneSourceDirectory() throws Exception {
522 final MavenProject project = createProject("group", "artifact", "version", null);
523
524 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
525 when(configSource.getFinalName()).thenReturn("final-name");
526 when(configSource.getProject()).thenReturn(project);
527 Artifact artifact = mock(Artifact.class);
528 when(artifact.getGroupId()).thenReturn("GROUPID");
529 project.setArtifact(artifact);
530
531 final Set<MavenProject> projects = singleton(project);
532
533 final FileSet fs = new FileSet();
534 fs.setDirectory("/src");
535 fs.setDirectoryMode("777");
536 fs.setFileMode("777");
537
538 final ModuleSources sources = new ModuleSources();
539 sources.addFileSet(fs);
540
541
542 final Archiver archiver = mock(Archiver.class);
543 when(archiver.getOverrideDirectoryMode()).thenReturn(-1);
544 when(archiver.getOverrideFileMode()).thenReturn(-1);
545
546 DefaultAssemblyArchiverTest.setupInterpolators(configSource, project);
547
548 this.phase.addModuleSourceFileSets(sources, projects, archiver, configSource);
549
550
551 verify(configSource).getArchiveBaseDirectory();
552 verify(configSource, atLeastOnce()).getFinalName();
553 verify(configSource, atLeastOnce()).getProject();
554 verify(configSource, atLeastOnce()).getMavenSession();
555
556 verify(archiver).getOverrideDirectoryMode();
557 verify(archiver).getOverrideFileMode();
558 }
559
560 @Test
561 public void testGetModuleProjects_ShouldReturnNothingWhenReactorContainsOnlyCurrentProject() throws Exception {
562 final MavenProject project = createProject("group", "artifact", "version", null);
563
564 final List<MavenProject> projects = Collections.singletonList(project);
565
566 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
567 when(configSource.getProject()).thenReturn(project);
568 when(configSource.getReactorProjects()).thenReturn(projects);
569
570 final ModuleSet moduleSet = new ModuleSet();
571 moduleSet.setIncludeSubModules(true);
572
573 final Set<MavenProject> moduleProjects =
574 ModuleSetAssemblyPhase.getModuleProjects(moduleSet, configSource, logger);
575
576 assertTrue(moduleProjects.isEmpty());
577
578
579 verify(configSource).getReactorProjects();
580 verify(configSource, atLeastOnce()).getProject();
581 }
582
583 @Test
584 public void testGetModuleProjects_ShouldReturnNothingWhenReactorContainsTwoSiblingProjects() throws Exception {
585 final MavenProject project = createProject("group", "artifact", "version", null);
586 final MavenProject project2 = createProject("group", "artifact2", "version", null);
587
588 final List<MavenProject> projects = new ArrayList<>();
589 projects.add(project);
590 projects.add(project2);
591
592 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
593 when(configSource.getReactorProjects()).thenReturn(projects);
594 when(configSource.getProject()).thenReturn(project);
595
596 final ModuleSet moduleSet = new ModuleSet();
597 moduleSet.setIncludeSubModules(true);
598
599 final Set<MavenProject> moduleProjects =
600 ModuleSetAssemblyPhase.getModuleProjects(moduleSet, configSource, logger);
601
602 assertTrue(moduleProjects.isEmpty());
603
604
605 verify(configSource).getReactorProjects();
606 verify(configSource, atLeastOnce()).getProject();
607 }
608
609 @Test
610 public void testGetModuleProjects_ShouldReturnModuleOfCurrentProject() throws Exception {
611 final MavenProject project = createProject("group", "artifact", "version", null);
612 final MavenProject project2 = createProject("group", "artifact2", "version", project);
613
614 final List<MavenProject> projects = new ArrayList<>();
615 projects.add(project);
616 projects.add(project2);
617
618 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
619 when(configSource.getReactorProjects()).thenReturn(projects);
620 when(configSource.getProject()).thenReturn(project);
621
622 final ModuleSet moduleSet = new ModuleSet();
623 moduleSet.setIncludeSubModules(true);
624
625 final Set<MavenProject> moduleProjects =
626 ModuleSetAssemblyPhase.getModuleProjects(moduleSet, configSource, logger);
627
628 assertFalse(moduleProjects.isEmpty());
629
630 final MavenProject result = moduleProjects.iterator().next();
631
632 assertEquals("artifact2", result.getArtifactId());
633
634
635 verify(configSource).getReactorProjects();
636 verify(configSource, atLeastOnce()).getProject();
637 }
638
639 @Test
640 public void testGetModuleProjects_ShouldReturnDescendentModulesOfCurrentProject() throws Exception {
641 final MavenProject project = createProject("group", "artifact", "version", null);
642 final MavenProject project2 = createProject("group", "artifact2", "version", project);
643 final MavenProject project3 = createProject("group", "artifact3", "version", project2);
644
645 final List<MavenProject> projects = new ArrayList<>();
646 projects.add(project);
647 projects.add(project2);
648 projects.add(project3);
649
650 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
651 when(configSource.getReactorProjects()).thenReturn(projects);
652 when(configSource.getProject()).thenReturn(project);
653
654 final ModuleSet moduleSet = new ModuleSet();
655 moduleSet.setIncludeSubModules(true);
656
657 final Set<MavenProject> moduleProjects =
658 ModuleSetAssemblyPhase.getModuleProjects(moduleSet, configSource, logger);
659
660 assertEquals(2, moduleProjects.size());
661
662 final List<MavenProject> check = new ArrayList<>();
663 check.add(project2);
664 check.add(project3);
665
666 verifyResultIs(check, moduleProjects);
667
668
669 verify(configSource).getReactorProjects();
670 verify(configSource, atLeastOnce()).getProject();
671 }
672
673 @Test
674 public void testGetModuleProjects_ShouldExcludeModuleAndDescendentsTransitively() throws Exception {
675 final MavenProject project = createProject("group", "artifact", "version", null);
676
677 Artifact artifact1 = mock(Artifact.class);
678 project.setArtifact(artifact1);
679
680 final MavenProject project2 = createProject("group", "artifact2", "version", project);
681 Artifact artifact2 = mock(Artifact.class);
682 when(artifact2.getGroupId()).thenReturn("group");
683 when(artifact2.getArtifactId()).thenReturn("artifact2");
684 lenient().when(artifact2.getId()).thenReturn("group:artifact2:version:jar");
685 lenient().when(artifact2.getDependencyConflictId()).thenReturn("group:artifact2:jar");
686 project2.setArtifact(artifact2);
687
688 final MavenProject project3 = createProject("group", "artifact3", "version", project2);
689 Artifact artifact3 = mock(Artifact.class);
690 when(artifact3.getGroupId()).thenReturn("group");
691 when(artifact3.getArtifactId()).thenReturn("artifact3");
692 lenient().when(artifact3.getId()).thenReturn("group:artifact3:version:jar");
693 lenient().when(artifact3.getDependencyConflictId()).thenReturn("group:artifact3:jar");
694 when(artifact3.getDependencyTrail()).thenReturn(Arrays.asList(project2.getId(), project.getId()));
695 project3.setArtifact(artifact3);
696
697 final List<MavenProject> projects = new ArrayList<>();
698 projects.add(project);
699 projects.add(project2);
700 projects.add(project3);
701
702 final AssemblerConfigurationSource configSource = mock(AssemblerConfigurationSource.class);
703 when(configSource.getReactorProjects()).thenReturn(projects);
704 when(configSource.getProject()).thenReturn(project);
705
706 final ModuleSet moduleSet = new ModuleSet();
707 moduleSet.setIncludeSubModules(true);
708
709 moduleSet.addExclude("group:artifact2");
710
711 final Set<MavenProject> moduleProjects =
712 ModuleSetAssemblyPhase.getModuleProjects(moduleSet, configSource, logger);
713
714 assertTrue(moduleProjects.isEmpty());
715
716
717 verify(configSource).getReactorProjects();
718 verify(configSource, atLeastOnce()).getProject();
719 }
720
721 private void verifyResultIs(final List<MavenProject> check, final Set<MavenProject> moduleProjects) {
722 boolean failed = false;
723
724 final Set<MavenProject> checkTooMany = new HashSet<>(moduleProjects);
725 check.forEach(checkTooMany::remove);
726
727 if (!checkTooMany.isEmpty()) {
728 failed = true;
729
730 System.out.println("Unexpected projects in output: ");
731
732 for (final MavenProject project : checkTooMany) {
733 System.out.println(project.getId());
734 }
735 }
736
737 final Set<MavenProject> checkTooFew = new HashSet<>(check);
738 checkTooFew.removeAll(moduleProjects);
739
740 if (!checkTooFew.isEmpty()) {
741 failed = true;
742
743 System.out.println("Expected projects missing from output: ");
744
745 for (final MavenProject project : checkTooMany) {
746 System.out.println(project.getId());
747 }
748 }
749
750 if (failed) {
751 fail("See system output for more information.");
752 }
753 }
754
755 private MavenProject createProject(
756 final String groupId, final String artifactId, final String version, final MavenProject parentProject) {
757 final Model model = new Model();
758 model.setArtifactId(artifactId);
759 model.setGroupId(groupId);
760 model.setVersion(version);
761
762 final MavenProject project = new MavenProject(model);
763
764 File pomFile;
765 if (parentProject == null) {
766 final File basedir = temporaryFolder.getRoot();
767 pomFile = new File(basedir, "pom.xml");
768 } else {
769 final File parentBase = parentProject.getBasedir();
770 pomFile = new File(parentBase, artifactId + "/pom.xml");
771
772 parentProject.getModel().addModule(artifactId);
773 project.setParent(parentProject);
774 }
775
776 project.setFile(pomFile);
777
778 return project;
779 }
780 }