View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
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          // required for mojo lookups to work
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      * New version of resolver on classpath does not support timestamp version lookups in local repository.
166      * TODO move to an integration test ...
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             // these will be null because no processing has occured only when everything is skipped
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             // make sure that we copy even if false is set - MDEP-80
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             // caught the expected exception.
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         // ensure dependency exists
351         item.setClassifier("sources");
352         item.setType("jar");
353 
354         // pre-create item
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         // pre-create item
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         // round up to the next second
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         // round up to the next second
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         // set dest to be old
669         long time = System.currentTimeMillis() - 10000;
670         time = time - (time % 1000);
671         assertTrue(copiedFile.setLastModified(time));
672 
673         // set source to be newer
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 }