1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.plugins.dependency.fromConfiguration;
20
21 import java.io.File;
22 import java.io.IOException;
23 import java.util.ArrayList;
24 import java.util.Collection;
25 import java.util.List;
26
27 import org.apache.maven.artifact.Artifact;
28 import org.apache.maven.artifact.versioning.VersionRange;
29 import org.apache.maven.execution.MavenSession;
30 import org.apache.maven.model.Dependency;
31 import org.apache.maven.plugin.MojoExecutionException;
32 import org.apache.maven.plugins.dependency.AbstractDependencyMojoTestCase;
33 import org.apache.maven.plugins.dependency.testUtils.stubs.DependencyProjectStub;
34 import org.apache.maven.plugins.dependency.utils.DependencyUtil;
35 import org.apache.maven.project.MavenProject;
36
37 public class TestCopyMojo extends AbstractDependencyMojoTestCase {
38 private CopyMojo mojo;
39
40 @Override
41 protected String getTestDirectoryName() {
42 return "copy";
43 }
44
45 @Override
46 protected boolean shouldCreateFiles() {
47 return false;
48 }
49
50 @Override
51 protected boolean shouldUseFlattenedPath() {
52 return false;
53 }
54
55 @Override
56 protected void setUp() throws Exception {
57
58 super.setUp();
59
60 MavenProject project = new DependencyProjectStub();
61 getContainer().addComponent(project, MavenProject.class.getName());
62
63 MavenSession session = newMavenSession(project);
64 getContainer().addComponent(session, MavenSession.class.getName());
65
66 File testPom = new File(getBasedir(), "target/test-classes/unit/copy-test/plugin-config.xml");
67 mojo = (CopyMojo) lookupMojo("copy", testPom);
68 mojo.setOutputDirectory(new File(this.testDir, "outputDirectory"));
69
70 assertNotNull(mojo);
71 assertNotNull(mojo.getProject());
72
73 installLocalRepository(session.getRepositorySession());
74 }
75
76 private ArtifactItem getSingleArtifactItem(boolean removeVersion, boolean useBaseVersion)
77 throws MojoExecutionException {
78 List<ArtifactItem> list = mojo.getProcessedArtifactItems(
79 new ProcessArtifactItemsRequest(removeVersion, false, useBaseVersion, false));
80 return list.get(0);
81 }
82
83 public void testSetArtifactWithoutPackaging() throws Exception {
84 mojo.setArtifact("a:b:c");
85 ArtifactItem item = mojo.getArtifactItems().get(0);
86 assertEquals("a", item.getGroupId());
87 assertEquals("b", item.getArtifactId());
88 assertEquals("c", item.getVersion());
89 assertEquals("jar", item.getType());
90 assertNull(item.getClassifier());
91 }
92
93 public void testSetArtifactWithoutClassifier() throws Exception {
94 mojo.setArtifact("a:b:c:d");
95 ArtifactItem item = mojo.getArtifactItems().get(0);
96 assertEquals("a", item.getGroupId());
97 assertEquals("b", item.getArtifactId());
98 assertEquals("c", item.getVersion());
99 assertEquals("d", item.getType());
100 assertNull(item.getClassifier());
101 }
102
103 public void testSetArtifact() throws Exception {
104 mojo.setArtifact("a:b:c:d:e");
105 ArtifactItem item = mojo.getArtifactItems().get(0);
106 assertEquals("a", item.getGroupId());
107 assertEquals("b", item.getArtifactId());
108 assertEquals("c", item.getVersion());
109 assertEquals("d", item.getType());
110 assertEquals("e", item.getClassifier());
111 }
112
113 public void testGetArtifactItems() throws Exception {
114
115 ArtifactItem item = new ArtifactItem();
116
117 item.setArtifactId("artifact");
118 item.setGroupId("groupId");
119 item.setVersion("1.0");
120
121 List<ArtifactItem> list = new ArrayList<>(1);
122 list.add(createArtifact(item));
123
124 mojo.setArtifactItems(createArtifactItemArtifacts(list));
125
126 ArtifactItem result = getSingleArtifactItem(false, false);
127 assertEquals(mojo.getOutputDirectory(), result.getOutputDirectory());
128
129 File output = new File(mojo.getOutputDirectory(), "override");
130 item.setOutputDirectory(output);
131 result = getSingleArtifactItem(false, false);
132 assertEquals(output, result.getOutputDirectory());
133 }
134
135 public void assertFilesExist(Collection<ArtifactItem> items, boolean exist) {
136 for (ArtifactItem item : items) {
137 assertFileExists(item, exist);
138 }
139 }
140
141 public void assertFileExists(ArtifactItem item, boolean exist) {
142 File file = new File(item.getOutputDirectory(), item.getDestFileName());
143 assertEquals(exist, file.exists());
144 }
145
146 public void testMojoDefaults() {
147 CopyMojo theMojo = new CopyMojo(null, null, null, null, null, null);
148
149 assertFalse(theMojo.isStripVersion());
150 assertFalse(theMojo.isSkip());
151 assertFalse(theMojo.isStripClassifier());
152 }
153
154 public void testCopyFile() throws Exception {
155 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
156
157 mojo.setArtifactItems(createArtifactItemArtifacts(list));
158
159 mojo.execute();
160
161 assertFilesExist(list, true);
162 }
163
164
165
166
167
168 public void skipTestCopyFileWithBaseVersion() throws Exception {
169 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
170 ArtifactItem item = new ArtifactItem();
171
172 item.setArtifactId("artifact");
173 item.setGroupId("groupId");
174 item.setVersion("1.0-20130210.213424-191");
175 list.add(item);
176
177 mojo.setArtifactItems(createArtifactItemArtifacts(list));
178 mojo.setUseBaseVersion(true);
179
180 mojo.execute();
181
182 assertFilesExist(list, true);
183 }
184
185 public void testSkip() throws Exception {
186 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
187
188 mojo.setSkip(true);
189 mojo.setArtifactItems(list);
190
191 mojo.execute();
192 for (ArtifactItem item : list) {
193
194 assertNull(item.getOutputDirectory());
195 assertNull(item.getDestFileName());
196 }
197 }
198
199 public void testCopyFileNoOverwrite() throws Exception {
200 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
201
202 for (ArtifactItem item : list) {
203
204 item.setOverWrite("false");
205 }
206
207 mojo.setArtifactItems(createArtifactItemArtifacts(list));
208 mojo.execute();
209
210 assertFilesExist(list, true);
211 }
212
213 public void testCopyToLocation() throws Exception {
214 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
215 ArtifactItem item = list.get(0);
216 item.setOutputDirectory(new File(mojo.getOutputDirectory(), "testOverride"));
217
218 mojo.setArtifactItems(createArtifactItemArtifacts(list));
219
220 mojo.execute();
221
222 assertFilesExist(list, true);
223 }
224
225 public void testCopyStripVersionSetInMojo() throws Exception {
226 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
227
228 ArtifactItem item = list.get(0);
229 item.setOutputDirectory(new File(mojo.getOutputDirectory(), "testOverride"));
230 mojo.setStripVersion(true);
231
232 mojo.setArtifactItems(createArtifactItemArtifacts(list));
233
234 mojo.execute();
235 assertEquals(DependencyUtil.getFormattedFileName(item.getArtifact(), true), item.getDestFileName());
236
237 assertFilesExist(list, true);
238 }
239
240 public void testCopyStripClassifierSetInMojo() throws Exception {
241 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
242
243 ArtifactItem item = list.get(0);
244 item.setOutputDirectory(new File(mojo.getOutputDirectory(), "testOverride"));
245 mojo.setStripClassifier(true);
246
247 mojo.setArtifactItems(createArtifactItemArtifacts(list));
248
249 mojo.execute();
250 assertEquals(
251 DependencyUtil.getFormattedFileName(item.getArtifact(), false, false, false, true),
252 item.getDestFileName());
253
254 assertFilesExist(list, true);
255 }
256
257 public void testNonClassifierStrip() throws Exception {
258 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getReleaseAndSnapshotArtifacts());
259 mojo.setStripVersion(true);
260 mojo.setArtifactItems(createArtifactItemArtifacts(list));
261
262 mojo.execute();
263
264 assertFilesExist(list, true);
265 }
266
267 public void testNonClassifierNoStrip() throws Exception {
268 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getReleaseAndSnapshotArtifacts());
269
270 mojo.setArtifactItems(createArtifactItemArtifacts(list));
271
272 mojo.execute();
273
274 assertFilesExist(list, true);
275 }
276
277 public void testMissingVersionNotFound() throws Exception {
278 ArtifactItem item = new ArtifactItem();
279
280 item.setArtifactId("artifactId");
281 item.setClassifier("");
282 item.setGroupId("groupId");
283 item.setType("type");
284
285 List<ArtifactItem> list = new ArrayList<>();
286 list.add(item);
287 mojo.setArtifactItems(list);
288
289 try {
290 mojo.execute();
291 fail("Expected Exception Here.");
292 } catch (MojoExecutionException e) {
293
294 }
295 }
296
297 public List<Dependency> getDependencyList(ArtifactItem item) {
298 Dependency dep = new Dependency();
299 dep.setArtifactId(item.getArtifactId());
300 dep.setClassifier(item.getClassifier());
301 dep.setGroupId(item.getGroupId());
302 dep.setType(item.getType());
303 dep.setVersion("2.0-SNAPSHOT");
304
305 Dependency dep2 = new Dependency();
306 dep2.setArtifactId(item.getArtifactId());
307 dep2.setClassifier("classifier");
308 dep2.setGroupId(item.getGroupId());
309 dep2.setType(item.getType());
310 dep2.setVersion("2.1");
311
312 List<Dependency> list = new ArrayList<>(2);
313 list.add(dep2);
314 list.add(dep);
315
316 return list;
317 }
318
319 public void testMissingVersionFromDependencies() throws Exception {
320 ArtifactItem item = new ArtifactItem();
321
322 item.setArtifactId("artifactId");
323 item.setClassifier("");
324 item.setGroupId("groupId");
325 item.setType("type");
326
327 List<ArtifactItem> list = new ArrayList<>();
328 list.add(item);
329 mojo.setArtifactItems(list);
330
331 MavenProject project = mojo.getProject();
332 project.setDependencies(createDependencyArtifacts(getDependencyList(item)));
333
334 mojo.execute();
335 this.assertFileExists(item, true);
336 assertEquals("2.0-SNAPSHOT", item.getVersion());
337 }
338
339 public void testMissingVersionFromDependenciesLooseMatch() throws Exception {
340 ArtifactItem item = new ArtifactItem();
341
342 item.setArtifactId("artifactId");
343 item.setClassifier("");
344 item.setGroupId("groupId");
345 item.setType("type");
346
347 MavenProject project = mojo.getProject();
348 project.setDependencies(createDependencyArtifacts(getDependencyList(item)));
349
350
351 item.setClassifier("sources");
352 item.setType("jar");
353
354
355 item.setVersion("2.1");
356 createArtifact(item);
357 item.setVersion(null);
358
359 List<ArtifactItem> list = new ArrayList<>();
360 list.add(item);
361 mojo.setArtifactItems(list);
362
363 mojo.execute();
364 this.assertFileExists(item, true);
365 assertEquals("2.1", item.getVersion());
366 }
367
368 public void testMissingVersionFromDependenciesWithClassifier() throws Exception {
369 ArtifactItem item = new ArtifactItem();
370
371 item.setArtifactId("artifactId");
372 item.setClassifier("classifier");
373 item.setGroupId("groupId");
374 item.setType("type");
375
376 List<ArtifactItem> list = new ArrayList<>();
377 list.add(item);
378 mojo.setArtifactItems(list);
379
380 MavenProject project = mojo.getProject();
381 project.setDependencies(createDependencyArtifacts(getDependencyList(item)));
382
383 mojo.execute();
384 this.assertFileExists(item, true);
385 assertEquals("2.1", item.getVersion());
386 }
387
388 public List<Dependency> getDependencyMgtList(ArtifactItem item) {
389 Dependency dep = new Dependency();
390 dep.setArtifactId(item.getArtifactId());
391 dep.setClassifier(item.getClassifier());
392 dep.setGroupId(item.getGroupId());
393 dep.setType(item.getType());
394 dep.setVersion("3.0-SNAPSHOT");
395
396 Dependency dep2 = new Dependency();
397 dep2.setArtifactId(item.getArtifactId());
398 dep2.setClassifier("classifier");
399 dep2.setGroupId(item.getGroupId());
400 dep2.setType(item.getType());
401 dep2.setVersion("3.1");
402
403 List<Dependency> list = new ArrayList<>(2);
404 list.add(dep2);
405 list.add(dep);
406
407 return list;
408 }
409
410 public void testMissingVersionFromDependencyMgt() throws Exception {
411 ArtifactItem item = new ArtifactItem();
412
413 item.setArtifactId("artifactId");
414 item.setClassifier("");
415 item.setGroupId("groupId");
416 item.setType("type");
417
418 MavenProject project = mojo.getProject();
419 project.setDependencies(getDependencyList(item));
420
421 item = new ArtifactItem();
422
423 item.setArtifactId("artifactId-2");
424 item.setClassifier("");
425 item.setGroupId("groupId");
426 item.setType("type");
427
428 List<ArtifactItem> list = new ArrayList<>();
429 list.add(item);
430
431 mojo.setArtifactItems(list);
432
433 project.getDependencyManagement().setDependencies(createDependencyArtifacts(getDependencyMgtList(item)));
434
435 mojo.execute();
436
437 this.assertFileExists(item, true);
438 assertEquals("3.0-SNAPSHOT", item.getVersion());
439 }
440
441 public void testMissingVersionFromDependencyMgtLooseMatch() throws Exception {
442 ArtifactItem item = new ArtifactItem();
443
444 item.setArtifactId("artifactId");
445 item.setClassifier("");
446 item.setGroupId("groupId");
447 item.setType("type");
448
449 MavenProject project = mojo.getProject();
450 project.setDependencies(getDependencyList(item));
451
452 item = new ArtifactItem();
453
454 item.setArtifactId("artifactId-2");
455 item.setClassifier("");
456 item.setGroupId("groupId");
457 item.setType("type");
458
459 List<ArtifactItem> list = new ArrayList<>();
460 list.add(item);
461
462 mojo.setArtifactItems(list);
463
464 project.getDependencyManagement().setDependencies(createDependencyArtifacts(getDependencyMgtList(item)));
465
466 item.setType("jar");
467
468
469 item.setVersion("3.1");
470 createArtifact(item);
471 item.setVersion(null);
472
473 mojo.execute();
474
475 this.assertFileExists(item, true);
476 assertEquals("3.1", item.getVersion());
477 }
478
479 public void testMissingVersionFromDependencyMgtWithClassifier() throws Exception {
480 ArtifactItem item = new ArtifactItem();
481
482 item.setArtifactId("artifactId");
483 item.setClassifier("classifier");
484 item.setGroupId("groupId");
485 item.setType("type");
486
487 MavenProject project = mojo.getProject();
488 project.setDependencies(getDependencyList(item));
489
490 item = new ArtifactItem();
491
492 item.setArtifactId("artifactId-2");
493 item.setClassifier("classifier");
494 item.setGroupId("groupId");
495 item.setType("type");
496
497 List<ArtifactItem> list = new ArrayList<>();
498 list.add(item);
499
500 mojo.setArtifactItems(list);
501
502 project.getDependencyManagement().setDependencies(createDependencyArtifacts(getDependencyMgtList(item)));
503
504 mojo.execute();
505
506 this.assertFileExists(item, true);
507 assertEquals("3.1", item.getVersion());
508 }
509
510 public void testArtifactNotFound() throws Exception {
511 ArtifactItem item = new ArtifactItem();
512
513 item.setArtifactId("artifactId");
514 item.setClassifier("");
515 item.setGroupId("groupId");
516 item.setType("type");
517 item.setVersion("1.0");
518
519 List<ArtifactItem> list = new ArrayList<>();
520 list.add(item);
521 mojo.setArtifactItems(list);
522
523 try {
524 mojo.execute();
525 fail("ExpectedException");
526 } catch (MojoExecutionException e) {
527 assertEquals("Unable to find/resolve artifact.", e.getMessage());
528 }
529 }
530
531 public void testNoArtifactItems() {
532 try {
533 mojo.getProcessedArtifactItems(new ProcessArtifactItemsRequest(false, false, false, false));
534 fail("Expected Exception");
535 } catch (MojoExecutionException e) {
536 assertEquals("There are no artifactItems configured.", e.getMessage());
537 }
538 }
539
540 public void testCopyDontOverWriteReleases() throws Exception {
541 stubFactory.setCreateFiles(true);
542 Artifact release = stubFactory.getReleaseArtifact();
543 assertTrue(release.getFile().setLastModified(System.currentTimeMillis() - 2000));
544
545 ArtifactItem item = new ArtifactItem(release);
546
547 List<ArtifactItem> list = new ArrayList<>(1);
548 list.add(item);
549 mojo.setArtifactItems(list);
550
551 mojo.setOverWriteIfNewer(false);
552
553 mojo.execute();
554
555 File copiedFile = new File(item.getOutputDirectory(), item.getDestFileName());
556
557 Thread.sleep(100);
558
559 long time = System.currentTimeMillis() + 1000;
560 time = time - (time % 1000);
561 copiedFile.setLastModified(time);
562 Thread.sleep(100);
563
564 mojo.execute();
565
566 assertEquals(time, copiedFile.lastModified());
567 }
568
569 public void testCopyDontOverWriteSnapshots() throws Exception {
570 stubFactory.setCreateFiles(true);
571 Artifact artifact = stubFactory.getSnapshotArtifact();
572 assertTrue(artifact.getFile().setLastModified(System.currentTimeMillis() - 2000));
573
574 ArtifactItem item = new ArtifactItem(artifact);
575
576 List<ArtifactItem> list = new ArrayList<>(1);
577 list.add(item);
578 mojo.setArtifactItems(list);
579
580 mojo.setOverWriteIfNewer(false);
581
582 mojo.execute();
583
584 File copiedFile = new File(item.getOutputDirectory(), item.getDestFileName());
585
586 Thread.sleep(100);
587
588 long time = System.currentTimeMillis() + 1000;
589 time = time - (time % 1000);
590 assertTrue(copiedFile.setLastModified(time));
591 Thread.sleep(100);
592
593 mojo.execute();
594
595 assertEquals(time, copiedFile.lastModified());
596 }
597
598 public void testCopyOverWriteReleases() throws Exception {
599 stubFactory.setCreateFiles(true);
600 Artifact release = stubFactory.getReleaseArtifact();
601 assertTrue(release.getFile().setLastModified(1000L));
602 assertEquals(1000L, release.getFile().lastModified());
603
604 ArtifactItem item = new ArtifactItem(release);
605
606 List<ArtifactItem> list = new ArrayList<>(1);
607 list.add(item);
608 mojo.setArtifactItems(list);
609
610 mojo.setOverWriteIfNewer(false);
611 mojo.setOverWriteReleases(true);
612 mojo.execute();
613
614 File copiedFile = new File(item.getOutputDirectory(), item.getDestFileName());
615
616 assertTrue(copiedFile.setLastModified(2000L));
617 assertEquals(2000L, copiedFile.lastModified());
618
619 mojo.execute();
620
621 long timeCopyNow = copiedFile.lastModified();
622 assertEquals(1000L, timeCopyNow);
623 }
624
625 public void testCopyOverWriteSnapshot() throws Exception {
626 stubFactory.setCreateFiles(true);
627 Artifact artifact = stubFactory.getSnapshotArtifact();
628 assertTrue(artifact.getFile().setLastModified(1000L));
629 assertEquals(1000L, artifact.getFile().lastModified());
630
631 ArtifactItem item = new ArtifactItem(artifact);
632
633 List<ArtifactItem> list = new ArrayList<>(1);
634 list.add(item);
635 mojo.setArtifactItems(list);
636
637 mojo.setOverWriteIfNewer(false);
638 mojo.setOverWriteReleases(false);
639 mojo.setOverWriteSnapshots(true);
640 mojo.execute();
641
642 File copiedFile = new File(item.getOutputDirectory(), item.getDestFileName());
643
644 assertTrue(copiedFile.setLastModified(2000L));
645 assertEquals(2000L, copiedFile.lastModified());
646
647 mojo.execute();
648
649 long timeCopyNow = copiedFile.lastModified();
650 assertEquals(1000L, timeCopyNow);
651 }
652
653 public void testCopyOverWriteIfNewer() throws Exception {
654 stubFactory.setCreateFiles(true);
655 Artifact artifact = stubFactory.getSnapshotArtifact();
656 assertTrue(artifact.getFile().setLastModified(System.currentTimeMillis() - 2000));
657
658 ArtifactItem item = new ArtifactItem(artifact);
659
660 List<ArtifactItem> list = new ArrayList<>(1);
661 list.add(item);
662 mojo.setArtifactItems(list);
663 mojo.setOverWriteIfNewer(true);
664 mojo.execute();
665
666 File copiedFile = new File(item.getOutputDirectory(), item.getDestFileName());
667
668
669 long time = System.currentTimeMillis() - 10000;
670 time = time - (time % 1000);
671 assertTrue(copiedFile.setLastModified(time));
672
673
674 assertTrue(artifact.getFile().setLastModified(time + 4000));
675 mojo.execute();
676
677 assertTrue(time < copiedFile.lastModified());
678 }
679
680 public void testCopyFileWithOverideLocalRepo() throws Exception {
681 final File localRepo = stubFactory.getWorkingDir();
682
683 List<ArtifactItem> list = stubFactory.getArtifactItems(stubFactory.getClassifiedArtifacts());
684
685 mojo.setArtifactItems(list);
686
687 File execLocalRepo = new File(this.testDir.getAbsolutePath(), "executionLocalRepo");
688 assertFalse(execLocalRepo.exists());
689
690 stubFactory.setWorkingDir(execLocalRepo);
691 createArtifactItemArtifacts(list);
692
693 assertFalse("default local repo should not exist", localRepo.exists());
694
695 mojo.setLocalRepositoryDirectory(execLocalRepo);
696
697 mojo.execute();
698
699 assertFilesExist(list, true);
700 }
701
702 private List<Dependency> createDependencyArtifacts(List<Dependency> items) throws IOException {
703 stubFactory.setCreateFiles(true);
704 for (Dependency item : items) {
705 String classifier = "".equals(item.getClassifier()) ? null : item.getClassifier();
706 stubFactory.createArtifact(
707 item.getGroupId(),
708 item.getArtifactId(),
709 VersionRange.createFromVersion(item.getVersion()),
710 null,
711 item.getType(),
712 classifier,
713 item.isOptional());
714 }
715 return items;
716 }
717
718 private List<ArtifactItem> createArtifactItemArtifacts(List<ArtifactItem> items) throws IOException {
719 for (ArtifactItem item : items) {
720 createArtifact(item);
721 }
722 return items;
723 }
724
725 private ArtifactItem createArtifact(ArtifactItem item) throws IOException {
726 stubFactory.setCreateFiles(true);
727
728 String classifier = "".equals(item.getClassifier()) ? null : item.getClassifier();
729 String version = item.getVersion() != null ? item.getVersion() : item.getBaseVersion();
730 stubFactory.createArtifact(item.getGroupId(), item.getArtifactId(), version, null, item.getType(), classifier);
731 return item;
732 }
733 }