1 package org.apache.maven.shared.release.phase;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.mockito.Mockito.mock;
23 import static org.mockito.Mockito.verify;
24 import static org.mockito.Mockito.verifyNoMoreInteractions;
25 import static org.mockito.Mockito.when;
26
27 import java.io.IOException;
28 import java.util.ArrayList;
29 import java.util.Collections;
30 import java.util.List;
31
32 import org.apache.maven.project.MavenProject;
33 import org.apache.maven.scm.manager.NoSuchScmProviderException;
34 import org.apache.maven.scm.manager.ScmManager;
35 import org.apache.maven.scm.manager.ScmManagerStub;
36 import org.apache.maven.scm.provider.ScmProvider;
37 import org.apache.maven.scm.repository.ScmRepositoryException;
38 import org.apache.maven.shared.release.ReleaseExecutionException;
39 import org.apache.maven.shared.release.ReleaseFailureException;
40 import org.apache.maven.shared.release.config.ReleaseDescriptor;
41 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
42 import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator;
43 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
44 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
45 import org.apache.maven.shared.release.util.ReleaseUtil;
46
47
48
49
50
51
52 public abstract class AbstractRewritingReleasePhaseTestCase
53 extends AbstractReleaseTestCase
54 {
55 public void testRewriteBasicPom()
56 throws Exception
57 {
58 List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
59 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
60 mapNextVersion( config, "groupId:artifactId" );
61
62 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
63
64 assertTrue( comparePomFiles( reactorProjects ) );
65 }
66
67 public void testRewriteBasicPomEntities()
68 throws Exception
69 {
70 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-entities" );
71 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
72 mapNextVersion( config, "groupId:artifactId" );
73
74 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
75
76 assertTrue( comparePomFiles( reactorProjects ) );
77 }
78
79 public void testRewriteBasicPomNamespace()
80 throws Exception
81 {
82 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-namespace" );
83 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
84 mapNextVersion( config, "groupId:artifactId" );
85
86 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
87
88 assertTrue( comparePomFiles( reactorProjects ) );
89 }
90
91 public void testRewriteBasicPomWithEncoding()
92 throws Exception
93 {
94 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-encoding" );
95 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
96 mapNextVersion( config, "groupId:artifactId" );
97
98 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
99
100 assertTrue( comparePomFiles( reactorProjects ) );
101 }
102
103 public void testRewritePomWithParent()
104 throws Exception
105 {
106 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
107 ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
108
109 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
110
111 assertTrue( comparePomFiles( reactorProjects ) );
112 }
113
114 public void testRewritePomWithUnmappedParent()
115 throws Exception
116 {
117
118 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
119 ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
120
121
122 reactorProjects = new ArrayList<MavenProject>( reactorProjects );
123 Collections.reverse( reactorProjects );
124
125 mapAlternateNextVersion( config, "groupId:subproject1" );
126
127 try
128 {
129 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
130
131 fail( "Should have thrown an exception" );
132 }
133 catch ( ReleaseFailureException e )
134 {
135 assertTrue( true );
136 }
137 }
138
139 public void testRewritePomWithReleasedParent()
140 throws Exception
141 {
142
143 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-released-parent" );
144 ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
145
146 mapAlternateNextVersion( config, "groupId:subproject1" );
147 config.mapReleaseVersion( "groupId:artifactId", "1" );
148 config.mapDevelopmentVersion( "groupId:artifactId", "1" );
149
150 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
151
152 assertTrue( comparePomFiles( reactorProjects ) );
153 }
154
155 protected abstract void mapAlternateNextVersion( ReleaseDescriptor config, String projectId );
156
157 public void testRewritePomWithInheritedVersion()
158 throws Exception
159 {
160 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
161 ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
162
163 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
164
165 assertTrue( comparePomFiles( reactorProjects ) );
166 }
167
168 public void testRewritePomWithChangedInheritedVersion()
169 throws Exception
170 {
171 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
172 ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
173
174 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
175
176 MavenProject project = (MavenProject) getProjectsAsMap( reactorProjects ).get( "groupId:subproject1" );
177 comparePomFiles( project, "-version-changed" );
178 }
179
180 protected abstract ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
181 throws Exception;
182
183 public void testRewritePomDependencies()
184 throws Exception
185 {
186 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
187 ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
188 mapNextVersion( config, "groupId:subsubproject" );
189
190 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
191
192 assertTrue( comparePomFiles( reactorProjects ) );
193 }
194
195 public void testRewritePomUnmappedDependencies()
196 throws Exception
197 {
198 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
199 ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
200
201 try
202 {
203 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
204
205 fail( "Should have thrown an exception" );
206 }
207 catch ( ReleaseFailureException e )
208 {
209 assertTrue( true );
210 }
211 }
212
213 public void testRewritePomDependenciesDifferentVersion()
214 throws Exception
215 {
216 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-dependencies" );
217 ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
218
219 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
220
221 assertTrue( comparePomFiles( reactorProjects ) );
222 }
223
224 public void testRewriteManagedPomDependencies()
225 throws Exception
226 {
227 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
228 ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
229
230 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
231
232 assertTrue( comparePomFiles( reactorProjects ) );
233 }
234
235 public void testRewriteManagedPomUnmappedDependencies()
236 throws Exception
237 {
238 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
239 ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
240
241 try
242 {
243 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
244
245 fail( "Should have thrown an exception" );
246 }
247 catch ( ReleaseFailureException e )
248 {
249 assertTrue( true );
250 }
251 }
252
253 public void testRewritePomPlugins()
254 throws Exception
255 {
256 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
257 ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
258
259 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
260
261 assertTrue( comparePomFiles( reactorProjects ) );
262 }
263
264 public void testRewritePomUnmappedPlugins()
265 throws Exception
266 {
267 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
268 ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
269
270 try
271 {
272 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
273
274 fail( "Should have thrown an exception" );
275 }
276 catch ( ReleaseFailureException e )
277 {
278 assertTrue( true );
279 }
280 }
281
282 public void testRewritePomPluginsDifferentVersion()
283 throws Exception
284 {
285 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-plugins" );
286 ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
287
288 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
289
290 assertTrue( comparePomFiles( reactorProjects ) );
291 }
292
293 public void testRewriteManagedPomPlugins()
294 throws Exception
295 {
296 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
297 ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
298
299 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
300
301 assertTrue( comparePomFiles( reactorProjects ) );
302 }
303
304 public void testRewriteManagedPomUnmappedPlugins()
305 throws Exception
306 {
307 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
308 ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
309
310 try
311 {
312 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
313
314 fail( "Should have thrown an exception" );
315 }
316 catch ( ReleaseFailureException e )
317 {
318 assertTrue( true );
319 }
320 }
321
322 public void testRewritePomReportPlugins()
323 throws Exception
324 {
325 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
326 ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
327
328 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
329
330 assertTrue( comparePomFiles( reactorProjects ) );
331 }
332
333 public void testRewritePomUnmappedReportPlugins()
334 throws Exception
335 {
336 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
337 ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
338
339 try
340 {
341 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
342
343 fail( "Should have thrown an exception" );
344 }
345 catch ( ReleaseFailureException e )
346 {
347 assertTrue( true );
348 }
349 }
350
351 public void testRewritePomReportPluginsDifferentVersion()
352 throws Exception
353 {
354 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-report-plugins" );
355 ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
356
357 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
358
359 assertTrue( comparePomFiles( reactorProjects ) );
360 }
361
362 public void testRewritePomExtension()
363 throws Exception
364 {
365 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
366 ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
367
368 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
369
370 assertTrue( comparePomFiles( reactorProjects ) );
371 }
372
373 public void testRewritePomUnmappedExtension()
374 throws Exception
375 {
376 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
377 ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
378
379 try
380 {
381 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
382
383 fail( "Should have thrown an exception" );
384 }
385 catch ( ReleaseFailureException e )
386 {
387 assertTrue( true );
388 }
389 }
390
391 public void testRewritePomExtensionDifferentVersion()
392 throws Exception
393 {
394 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-extension" );
395 ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
396
397 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
398
399 assertTrue( comparePomFiles( reactorProjects ) );
400 }
401
402 public void testRewritePomExtensionUndefinedVersion()
403 throws Exception
404 {
405 List<MavenProject> reactorProjects = createReactorProjects( "pom-without-extension-version" );
406 ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
407
408 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
409
410 assertTrue( comparePomFiles( reactorProjects ) );
411 }
412
413 public void testRewriteAddSchema()
414 throws Exception
415 {
416 boolean copyFiles = true;
417
418
419 for ( int i = 0; i < 2; i++ )
420 {
421 String path = "basic-pom";
422 List<MavenProject> reactorProjects = prepareReactorProjects( path, copyFiles );
423 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
424 mapNextVersion( config, "groupId:artifactId" );
425 config.setAddSchema( true );
426
427 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
428
429 comparePomFiles( reactorProjects, "-with-schema" );
430
431 copyFiles = false;
432
433 verifyReactorProjects( path, copyFiles );
434 }
435 }
436
437 public void testSimulateRewriteEditModeSkipped()
438 throws Exception
439 {
440
441 List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
442 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
443 config.setScmUseEditMode( true );
444 mapNextVersion( config, "groupId:artifactId" );
445
446 ScmProvider scmProviderMock = mock( ScmProvider.class );
447
448 ScmManagerStub scmManager = new ScmManagerStub();
449 DefaultScmRepositoryConfigurator configurator =
450 (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
451 configurator.setScmManager( scmManager );
452 scmManager.setScmProvider( scmProviderMock );
453
454
455 phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
456
457
458 verifyNoMoreInteractions( scmProviderMock );
459 }
460
461 public void testRewriteUnmappedPom()
462 throws Exception
463 {
464 List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
465 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
466
467 try
468 {
469 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
470
471 fail( "Should have thrown an exception" );
472 }
473 catch ( ReleaseFailureException e )
474 {
475 assertTrue( true );
476 }
477 }
478
479 public void testRewriteBasicPomWithScmRepoException()
480 throws Exception
481 {
482
483 List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
484 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
485 config.setScmUseEditMode( true );
486 mapNextVersion( config, "groupId:artifactId" );
487
488 ScmManager scmManagerMock = mock( ScmManager.class );
489 when( scmManagerMock.makeScmRepository( config.getScmSourceUrl() ) ).thenThrow( new ScmRepositoryException( "..." ) );
490
491 DefaultScmRepositoryConfigurator configurator =
492 (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
493 configurator.setScmManager( scmManagerMock );
494
495 try
496 {
497 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
498
499 fail( "Should have thrown an exception" );
500 }
501 catch ( ReleaseScmRepositoryException e )
502 {
503 assertNull( "Check no additional cause", e.getCause() );
504 }
505
506 verify( scmManagerMock ).makeScmRepository( config.getScmSourceUrl() );
507 verifyNoMoreInteractions( scmManagerMock );
508 }
509
510 public void testRewriteBasicPomWithNoSuchProviderException()
511 throws Exception
512 {
513
514 List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
515 ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
516 config.setScmUseEditMode( true );
517 mapNextVersion( config, "groupId:artifactId" );
518
519 ScmManager scmManagerMock = mock( ScmManager.class );
520 when( scmManagerMock.makeScmRepository( config.getScmSourceUrl() ) ).thenThrow( new NoSuchScmProviderException( "..." ) );
521
522 DefaultScmRepositoryConfigurator configurator =
523 (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
524 configurator.setScmManager( scmManagerMock );
525
526
527 try
528 {
529 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
530
531 fail( "Should have thrown an exception" );
532 }
533 catch ( ReleaseExecutionException e )
534 {
535 assertEquals( "Check cause", NoSuchScmProviderException.class, e.getCause().getClass() );
536 }
537
538
539 verify( scmManagerMock ).makeScmRepository( config.getScmSourceUrl() );
540 verifyNoMoreInteractions( scmManagerMock );
541 }
542
543 public void testRewriteWhitespaceAroundValues()
544 throws Exception
545 {
546 List<MavenProject> reactorProjects = createReactorProjects( "whitespace-around-values" );
547 ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
548 mapNextVersion( config, "groupId:subproject2" );
549
550 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
551
552 assertTrue( comparePomFiles( reactorProjects ) );
553 }
554
555 public void testRewriteCommentsAroundValues()
556 throws Exception
557 {
558 List<MavenProject> reactorProjects = createReactorProjects( "comments-around-values" );
559 ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
560 mapNextVersion( config, "groupId:subproject2" );
561
562 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
563
564 assertTrue( comparePomFiles( reactorProjects ) );
565 }
566
567 public void testRewriteCDataAroundValues()
568 throws Exception
569 {
570 List<MavenProject> reactorProjects = createReactorProjects( "cdata-around-values" );
571 ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
572 mapNextVersion( config, "groupId:subproject2" );
573
574 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
575
576 assertTrue( comparePomFiles( reactorProjects ) );
577 }
578
579 public void testCleanNoProjects()
580 throws Exception
581 {
582
583 ReleaseDescriptor config = new ReleaseDescriptor();
584 config.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
585 config.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
586
587 phase.clean( Collections.<MavenProject>emptyList() );
588
589 assertTrue( true );
590 }
591
592 protected ReleaseDescriptor createUnmappedConfiguration( List<MavenProject> reactorProjects )
593 throws Exception
594 {
595 ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
596
597 unmapNextVersion( config, "groupId:subproject1" );
598 mapNextVersion( config, "groupId:subproject2" );
599 mapNextVersion( config, "groupId:subproject3" );
600 mapNextVersion( config, "groupId:artifactId" );
601 return config;
602 }
603
604 protected List<MavenProject> createReactorProjects( String path )
605 throws Exception
606 {
607 return prepareReactorProjects( path, true );
608 }
609
610 protected ReleaseDescriptor createDefaultConfiguration( List<MavenProject> reactorProjects )
611 throws Exception
612 {
613 ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
614
615 mapNextVersion( config, "groupId:subproject4" );
616 return config;
617 }
618
619 protected ReleaseDescriptor createMappedConfiguration( List<MavenProject> reactorProjects )
620 throws Exception
621 {
622 ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
623
624 mapNextVersion( config, "groupId:subproject3" );
625 return config;
626 }
627
628 private ReleaseDescriptor createDifferingVersionConfiguration( List<MavenProject> reactorProjects )
629 throws Exception
630 {
631 ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
632
633 mapNextVersion( config, "groupId:subproject2" );
634 return config;
635 }
636
637 protected List<MavenProject> createReactorProjectsFromBasicPom()
638 throws Exception
639 {
640 return createReactorProjects( "basic-pom" );
641 }
642
643 protected abstract ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
644 throws Exception;
645
646 protected abstract void unmapNextVersion( ReleaseDescriptor config, String projectId );
647
648 protected abstract void mapNextVersion( ReleaseDescriptor config, String projectId );
649
650 protected ReleaseDescriptor createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
651 throws Exception
652 {
653 return createDescriptorFromProjects( reactorProjects );
654 }
655
656 protected abstract String readTestProjectFile( String fileName )
657 throws IOException;
658
659 public void testRewritePomDependenciesWithNamespace()
660 throws Exception
661 {
662 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-namespace" );
663 ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
664
665 phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
666
667 assertTrue( comparePomFiles( reactorProjects ) );
668 }
669
670 protected abstract List<MavenProject> prepareReactorProjects( String path, boolean copyFiles )
671 throws Exception;
672
673 protected void verifyReactorProjects( String path, boolean copyFiles ) throws Exception
674 {
675 }
676
677 protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
678 {
679 ReleaseDescriptor descriptor = new ReleaseDescriptor();
680 MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
681 if ( rootProject.getScm() == null )
682 {
683 descriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
684 }
685 else
686 {
687 descriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
688 }
689
690 descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
691
692 return descriptor;
693 }
694 }