1 package org.apache.maven.shared.filtering;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.File;
23 import java.io.FileInputStream;
24 import java.io.IOException;
25 import java.nio.file.Files;
26 import java.util.ArrayList;
27 import java.util.Arrays;
28 import java.util.Collections;
29 import java.util.List;
30 import java.util.Properties;
31
32 import org.apache.commons.io.FileUtils;
33 import org.apache.maven.execution.MavenSession;
34 import org.apache.maven.model.Resource;
35 import org.apache.maven.settings.Settings;
36 import org.codehaus.plexus.PlexusTestCase;
37 import org.codehaus.plexus.interpolation.PrefixedObjectValueSource;
38 import org.codehaus.plexus.interpolation.ValueSource;
39
40
41
42
43
44
45 public class DefaultMavenResourcesFilteringTest
46 extends PlexusTestCase
47 {
48
49 private File outputDirectory = new File( getBasedir(), "target/DefaultMavenResourcesFilteringTest" );
50 private File baseDir = new File( "c:\\foo\\bar" );
51 private StubMavenProject mavenProject = new StubMavenProject( baseDir );
52 private MavenResourcesFiltering mavenResourcesFiltering;
53
54 @Override
55 protected void setUp()
56 throws Exception
57 {
58 super.setUp();
59 if ( outputDirectory.exists() )
60 {
61 FileUtils.deleteDirectory( outputDirectory );
62 }
63 outputDirectory.mkdirs();
64
65 mavenProject.setVersion( "1.0" );
66 mavenProject.setGroupId( "org.apache" );
67 mavenProject.setName( "test project" );
68
69 mavenResourcesFiltering = lookup( MavenResourcesFiltering.class );
70 }
71
72 public void testSimpleFiltering()
73 throws Exception
74 {
75 Properties projectProperties = new Properties();
76 projectProperties.put( "foo", "bar" );
77 projectProperties.put( "java.version", "zloug" );
78 mavenProject.setProperties( projectProperties );
79
80 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
81 File initialImageFile = new File( unitFilesDir, "happy_duke.gif" );
82
83 Resource resource = new Resource();
84 List<Resource> resources = new ArrayList<>();
85 resources.add( resource );
86 resource.setDirectory( unitFilesDir );
87 resource.setFiltering( true );
88
89 List<String> filtersFile = new ArrayList<>();
90 filtersFile.add( getBasedir()
91 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
92
93 List<String> nonFilteredFileExtensions = Collections.singletonList( "gif" );
94
95 MavenResourcesExecution mavenResourcesExecution =
96 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
97 nonFilteredFileExtensions, new StubMavenSession() );
98 mavenResourcesExecution.setUseDefaultFilterWrappers( true );
99 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
100
101 assertFiltering( initialImageFile, false, false );
102 }
103
104 public void testSessionFiltering()
105 throws Exception
106 {
107
108 String unitFilesDir = getBasedir() + "/src/test/units-files/session-filtering";
109
110 Resource resource = new Resource();
111 List<Resource> resources = new ArrayList<>();
112 resources.add( resource );
113 resource.setDirectory( unitFilesDir );
114 resource.setFiltering( true );
115
116 List<String> filtersFile = new ArrayList<>();
117
118 Settings settings = new Settings();
119 settings.setLocalRepository( System.getProperty( "localRepository",
120 System.getProperty( "maven.repo.local",
121 "/path/to/local/repo" ) ) );
122
123 MavenSession session = new StubMavenSession( settings );
124
125 MavenResourcesExecution mre = new MavenResourcesExecution();
126 mre.setResources( resources );
127 mre.setOutputDirectory( outputDirectory );
128 mre.setEncoding( "UTF-8" );
129 mre.setMavenProject( mavenProject );
130 mre.setFilters( filtersFile );
131 mre.setNonFilteredFileExtensions( Collections.<String> emptyList() );
132 mre.setMavenSession( session );
133 mre.setUseDefaultFilterWrappers( true );
134
135 mavenResourcesFiltering.filterResources( mre );
136
137 Properties result = new Properties();
138
139 try ( FileInputStream in = new FileInputStream( new File( outputDirectory, "session-filter-target.txt" ) ) )
140 {
141 result.load( in );
142 }
143
144 assertEquals( settings.getLocalRepository(), result.getProperty( "session.settings.local.repo" ) );
145 assertEquals( settings.getLocalRepository(), result.getProperty( "settings.local.repo" ) );
146 assertEquals( settings.getLocalRepository(), result.getProperty( "local.repo" ) );
147 }
148
149 public void testWithMavenResourcesExecution()
150 throws Exception
151 {
152 Properties projectProperties = new Properties();
153 projectProperties.put( "foo", "bar" );
154 projectProperties.put( "java.version", "zloug" );
155 mavenProject.setProperties( projectProperties );
156
157 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
158 File initialImageFile = new File( unitFilesDir, "happy_duke.gif" );
159
160 Resource resource = new Resource();
161 List<Resource> resources = new ArrayList<>();
162 resources.add( resource );
163 resource.setDirectory( unitFilesDir );
164 resource.setFiltering( true );
165
166 List<String> filtersFile = new ArrayList<>();
167 filtersFile.add( getBasedir()
168 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
169
170 List<String> nonFilteredFileExtensions = Collections.singletonList( "gif" );
171 MavenResourcesExecution mavenResourcesExecution =
172 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
173 nonFilteredFileExtensions, new StubMavenSession() );
174 mavenResourcesExecution.setEscapeString( "\\" );
175 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
176 assertFiltering( initialImageFile, true, false );
177 }
178
179 public void testWithMavenResourcesExecutionWithAdditionalProperties()
180 throws Exception
181 {
182 Properties projectProperties = new Properties();
183 projectProperties.put( "foo", "bar" );
184 projectProperties.put( "java.version", "zloug" );
185 mavenProject.setProperties( projectProperties );
186
187 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
188 File initialImageFile = new File( unitFilesDir, "happy_duke.gif" );
189
190 Resource resource = new Resource();
191 List<Resource> resources = new ArrayList<>();
192 resources.add( resource );
193 resource.setDirectory( unitFilesDir );
194 resource.setFiltering( true );
195
196 List<String> filtersFile = new ArrayList<>();
197 filtersFile.add( getBasedir()
198 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
199
200 List<String> nonFilteredFileExtensions = Collections.singletonList( "gif" );
201 Properties additionalProperties = new Properties();
202 additionalProperties.put( "greatDate", "1973-06-14" );
203 additionalProperties.put( "pom.version", "99.00" );
204 MavenResourcesExecution mavenResourcesExecution =
205 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
206 nonFilteredFileExtensions, new StubMavenSession() );
207 mavenResourcesExecution.setAdditionalProperties( additionalProperties );
208 mavenResourcesExecution.setEscapeString( "\\" );
209 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
210 assertFiltering( initialImageFile, true, true );
211 }
212
213 private void assertFiltering( File initialImageFile, boolean escapeTest,
214 boolean additionalProperties )
215 throws Exception
216 {
217 assertEquals( 7, outputDirectory.listFiles().length );
218 Properties result = new Properties();
219
220 try ( FileInputStream in = new FileInputStream( new File( outputDirectory, "empty-maven-resources-filtering.txt" ) ) )
221 {
222 result.load( in );
223 }
224
225 assertTrue( result.isEmpty() );
226
227 result = new Properties();
228
229 try ( FileInputStream in = new FileInputStream( new File( outputDirectory, "maven-resources-filtering.txt" ) ) )
230 {
231 result.load( in );
232 }
233
234 assertFalse( result.isEmpty() );
235
236 if ( additionalProperties )
237 {
238 assertEquals( "1973-06-14", result.getProperty( "goodDate" ) );
239 assertEquals( "99.00", result.get( "version" ) );
240 }
241 else
242 {
243 assertEquals( "1.0", result.get( "version" ) );
244 }
245 assertEquals( "org.apache", result.get( "groupId" ) );
246 assertEquals( "bar", result.get( "foo" ) );
247 assertEquals( "${foo.version}", result.get( "fooVersion" ) );
248
249 assertEquals( "@@", result.getProperty( "emptyexpression" ) );
250 assertEquals( "${}", result.getProperty( "emptyexpression2" ) );
251 assertEquals( System.getProperty( "user.dir" ), result.getProperty( "userDir" ) );
252 String userDir = result.getProperty( "userDir" );
253 assertTrue( new File( userDir ).exists() );
254 assertEquals( new File( System.getProperty( "user.dir" ) ), new File( userDir ) );
255 assertEquals( System.getProperty( "java.version" ), result.getProperty( "javaVersion" ) );
256
257 String userHome = result.getProperty( "userHome" );
258
259 assertTrue( "'" + userHome + "' does not exist.", new File( userHome ).exists() );
260 assertEquals( new File( System.getProperty( "user.home" ) ), new File( userHome ) );
261
262 if ( escapeTest )
263 {
264 assertEquals( "${java.version}", result.getProperty( "escapeJavaVersion" ) );
265 assertEquals( "@user.dir@", result.getProperty( "escapeuserDir" ) );
266 }
267 assertEquals( baseDir.toString(), result.get( "base" ) );
268 assertEquals( new File( baseDir.toString() ).getPath(), new File( result.getProperty( "base" ) ).getPath() );
269
270 File imageFile = new File( outputDirectory, "happy_duke.gif" );
271 assertTrue( imageFile.exists() );
272
273 assertTrue( filesAreIdentical( initialImageFile, imageFile ) );
274 }
275
276 public void testAddingTokens()
277 throws Exception
278 {
279 Properties projectProperties = new Properties();
280 projectProperties.put( "foo", "bar" );
281 projectProperties.put( "java.version", "zloug" );
282 mavenProject.setProperties( projectProperties );
283
284 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
285 File initialImageFile = new File( unitFilesDir, "happy_duke.gif" );
286
287 Resource resource = new Resource();
288 List<Resource> resources = new ArrayList<>();
289 resources.add( resource );
290 resource.setDirectory( unitFilesDir );
291 resource.setFiltering( true );
292
293 List<String> filtersFile = new ArrayList<>();
294 filtersFile.add( getBasedir()
295 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
296
297 List<String> nonFilteredFileExtensions = Collections.singletonList( "gif" );
298
299 MavenResourcesExecution mavenResourcesExecution =
300 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", null,
301 nonFilteredFileExtensions, new StubMavenSession() );
302
303 ValueSource vs =
304 new PrefixedObjectValueSource( mavenResourcesExecution.getProjectStartExpressions(), mavenProject, true );
305
306 mavenResourcesExecution.addFilerWrapperWithEscaping( vs, "@", "@", null, false );
307
308 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
309 Properties result =
310 PropertyUtils.loadPropertyFile( new File( outputDirectory, "maven-resources-filtering.txt" ), null );
311 assertFalse( result.isEmpty() );
312 assertEquals( mavenProject.getName(), result.get( "pomName" ) );
313 assertFiltering( initialImageFile, false, false );
314 }
315
316 public void testNoFiltering()
317 throws Exception
318 {
319
320 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
321 File initialImageFile = new File( unitFilesDir, "happy_duke.gif" );
322
323 Resource resource = new Resource();
324 List<Resource> resources = new ArrayList<>();
325 resources.add( resource );
326
327 resource.setDirectory( unitFilesDir );
328 resource.setFiltering( false );
329
330 MavenResourcesExecution mre = new MavenResourcesExecution();
331 mre.setResources( resources );
332 mre.setOutputDirectory( outputDirectory );
333 mre.setEncoding( "UTF-8" );
334 mre.setMavenProject( mavenProject );
335 mre.setFilters( null );
336 mre.setNonFilteredFileExtensions( Collections.<String> emptyList() );
337 mre.setMavenSession( new StubMavenSession() );
338
339 mavenResourcesFiltering.filterResources( mre );
340
341 assertEquals( 7, outputDirectory.listFiles().length );
342 Properties result =
343 PropertyUtils.loadPropertyFile( new File( outputDirectory, "empty-maven-resources-filtering.txt" ), null );
344 assertTrue( result.isEmpty() );
345
346 result = PropertyUtils.loadPropertyFile( new File( outputDirectory, "maven-resources-filtering.txt" ), null );
347 assertFalse( result.isEmpty() );
348
349 assertEquals( "${pom.version}", result.get( "version" ) );
350 assertEquals( "${pom.groupId}", result.get( "groupId" ) );
351 assertEquals( "${foo}", result.get( "foo" ) );
352 assertEquals( "@@", result.getProperty( "emptyexpression" ) );
353 assertEquals( "${}", result.getProperty( "emptyexpression2" ) );
354 File imageFile = new File( outputDirectory, "happy_duke.gif" );
355 assertTrue( filesAreIdentical( initialImageFile, imageFile ) );
356 }
357
358 private static boolean filesAreIdentical( File expected, File current )
359 throws IOException
360 {
361 if ( expected.length() != current.length() )
362 {
363 return false;
364 }
365
366 byte[] expectedBuffer = Files.readAllBytes( expected.toPath() );
367 byte[] currentBuffer = Files.readAllBytes( current.toPath() );
368 if ( expectedBuffer.length != currentBuffer.length )
369 {
370 return false;
371 }
372 for ( int i = 0, size = expectedBuffer.length; i < size; i++ )
373 {
374 if ( expectedBuffer[i] != currentBuffer[i] )
375 {
376 return false;
377 }
378 }
379 return true;
380 }
381
382 public void testIncludeOneFile()
383 throws Exception
384 {
385
386 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
387
388 Resource resource = new Resource();
389 List<Resource> resources = new ArrayList<>();
390 resources.add( resource );
391 resource.setDirectory( unitFilesDir );
392 resource.setFiltering( true );
393 resource.addInclude( "includ*" );
394
395 List<String> filtersFile = new ArrayList<>();
396 filtersFile.add( getBasedir()
397 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
398
399 MavenResourcesExecution mavenResourcesExecution =
400 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
401 Collections.<String> emptyList(), new StubMavenSession() );
402 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
403
404 File[] files = outputDirectory.listFiles();
405 assertEquals( 1, files.length );
406 assertEquals( "includefile.txt", files[0].getName() );
407
408 }
409
410 public void testIncludeOneFileAndDirectory()
411 throws Exception
412 {
413 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
414
415 Resource resource = new Resource();
416 List<Resource> resources = new ArrayList<>();
417 resources.add( resource );
418 resource.setDirectory( unitFilesDir );
419 resource.setFiltering( true );
420 resource.addInclude( "includ*" );
421 resource.addInclude( "**/includ*" );
422
423 List<String> filtersFile = new ArrayList<>();
424 filtersFile.add( getBasedir()
425 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
426
427 MavenResourcesExecution mavenResourcesExecution =
428 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
429 Collections.<String> emptyList(), new StubMavenSession() );
430 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
431
432 File[] files = outputDirectory.listFiles();
433 assertNotNull( files );
434 assertEquals( 2, files.length );
435 File includeFile = new File( outputDirectory, "includefile.txt" );
436 assertTrue( includeFile.exists() );
437
438 includeFile = new File( new File( outputDirectory, "includedir" ), "include.txt" );
439 assertTrue( includeFile.exists() );
440
441 }
442
443 public void testExcludeOneFile()
444 throws Exception
445 {
446
447 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
448
449 Resource resource = new Resource();
450 List<Resource> resources = new ArrayList<>();
451 resources.add( resource );
452 resource.setDirectory( unitFilesDir );
453 resource.setFiltering( true );
454 resource.addExclude( "*.gif" );
455 resource.addExclude( "**/excludedir/**" );
456
457 List<String> filtersFile = new ArrayList<>();
458 filtersFile.add( getBasedir()
459 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
460
461 MavenResourcesExecution mavenResourcesExecution =
462 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
463 Collections.<String> emptyList(), new StubMavenSession() );
464 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
465
466 File[] files = outputDirectory.listFiles();
467 assertEquals( 5, files.length );
468 File includeFile = new File( outputDirectory, "includefile.txt" );
469 assertTrue( includeFile.exists() );
470
471 includeFile = new File( new File( outputDirectory, "includedir" ), "include.txt" );
472 assertTrue( includeFile.exists() );
473
474 File imageFile = new File( outputDirectory, "happy_duke.gif" );
475 assertFalse( imageFile.exists() );
476
477 File excludeDir = new File( outputDirectory, "excludedir" );
478 assertFalse( excludeDir.exists() );
479 }
480
481 public void testTargetAbsolutePath()
482 throws Exception
483 {
484
485 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
486
487 Resource resource = new Resource();
488 List<Resource> resources = new ArrayList<>();
489 resources.add( resource );
490 resource.setDirectory( unitFilesDir );
491 resource.setFiltering( true );
492 resource.addInclude( "includ*" );
493
494 String targetPath = getBasedir() + "/target/testAbsolutePath/";
495 File targetPathFile = new File( targetPath );
496 resource.setTargetPath( targetPathFile.getAbsolutePath() );
497
498 if ( !targetPathFile.exists() )
499 {
500 targetPathFile.mkdirs();
501 }
502 else
503 {
504 FileUtils.cleanDirectory( targetPathFile );
505 }
506 List<String> filtersFile = new ArrayList<>();
507 filtersFile.add( getBasedir()
508 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
509
510 MavenResourcesExecution mavenResourcesExecution =
511 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
512 Collections.<String> emptyList(), new StubMavenSession() );
513 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
514
515 File[] files = targetPathFile.listFiles();
516 assertEquals( 1, files.length );
517 assertEquals( "includefile.txt", files[0].getName() );
518 }
519
520 public void testTargetPath()
521 throws Exception
522 {
523
524 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-resources-filtering";
525
526 Resource resource = new Resource();
527 List<Resource> resources = new ArrayList<>();
528 resources.add( resource );
529 resource.setDirectory( unitFilesDir );
530 resource.setFiltering( true );
531 resource.addInclude( "includ*" );
532 resource.setTargetPath( "testTargetPath" );
533 List<String> filtersFile = new ArrayList<>();
534 filtersFile.add( getBasedir()
535 + "/src/test/units-files/maven-resources-filtering/empty-maven-resources-filtering.txt" );
536
537 MavenResourcesExecution mavenResourcesExecution =
538 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8", filtersFile,
539 Collections.<String> emptyList(), new StubMavenSession() );
540 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
541
542 File targetPathFile = new File( outputDirectory, "testTargetPath" );
543
544 File[] files = targetPathFile.listFiles();
545 assertEquals( 1, files.length );
546 assertEquals( "includefile.txt", files[0].getName() );
547 }
548
549 @SuppressWarnings( "serial" )
550 public void testEmptyDirectories()
551 throws Exception
552 {
553
554 List<Resource> resources = new ArrayList<>();
555 resources.add( new Resource()
556 {
557 {
558 setDirectory( getBasedir() + "/src/test/units-files/includeEmptyDirs" );
559 setExcludes( Arrays.asList( "**/.gitignore" ) );
560 }
561 } );
562 MavenResourcesExecution mavenResourcesExecution =
563 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8",
564 Collections.<String> emptyList(), Collections.<String> emptyList(),
565 new StubMavenSession() );
566 mavenResourcesExecution.setIncludeEmptyDirs( true );
567 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
568
569 File[] childs = outputDirectory.listFiles();
570 assertNotNull( childs );
571 assertEquals( 3, childs.length );
572
573 for ( File file : childs )
574 {
575 if ( file.getName().endsWith( "dir1" ) || file.getName().endsWith( "empty-directory" )
576 || file.getName().endsWith( "empty-directory-child" ) )
577 {
578 if ( file.getName().endsWith( "dir1" ) )
579 {
580 assertEquals( 1, file.list().length );
581 assertTrue( file.listFiles()[0].getName().endsWith( "foo.txt" ) );
582 }
583 if ( file.getName().endsWith( "empty-directory" ) )
584 {
585 assertEquals( 0, file.list().length );
586 }
587 if ( file.getName().endsWith( "empty-directory-child" ) )
588 {
589 assertEquals( 1, file.list().length );
590 assertTrue( file.listFiles()[0].isDirectory() );
591 assertEquals( 0, file.listFiles()[0].listFiles().length );
592 }
593 }
594 else
595 {
596 fail( "unknow child file found " + file.getName() );
597 }
598 }
599 }
600
601 @SuppressWarnings( "serial" )
602 public void testShouldReturnGitIgnoreFiles()
603 throws Exception
604 {
605 createTestDataStructure();
606
607 File outputDirectory = new File( getBasedir(), "/target/testGitIgnoreFile" );
608
609
610 List<Resource> resources = new ArrayList<>();
611 resources.add( new Resource()
612 {
613 {
614 setDirectory( getBasedir() + "/target/sourceTestGitIgnoreFile" );
615 setIncludes( Arrays.asList( "**/*" ) );
616 }
617 } );
618 MavenResourcesExecution mavenResourcesExecution =
619 new MavenResourcesExecution( resources, outputDirectory, mavenProject, "UTF-8",
620 Collections.<String> emptyList(), Collections.<String> emptyList(),
621 new StubMavenSession() );
622 mavenResourcesExecution.setIncludeEmptyDirs( true );
623 mavenResourcesExecution.setAddDefaultExcludes( false );
624 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
625
626 File[] children = outputDirectory.listFiles();
627 assertNotNull( children );
628 assertEquals( 3, children.length );
629
630 for ( File file : children )
631 {
632 if ( file.getName().endsWith( "dir1" ) || file.getName().endsWith( "empty-directory" )
633 || file.getName().endsWith( "empty-directory-child" ) )
634 {
635 if ( file.getName().endsWith( "dir1" ) )
636 {
637 assertEquals( 1, file.list().length );
638 assertTrue( file.listFiles()[0].getName().endsWith( "foo.txt" ) );
639 }
640 if ( file.getName().endsWith( "empty-directory" ) )
641 {
642
643 assertEquals( 1, file.list().length );
644 assertTrue( file.listFiles()[0].getName().endsWith( ".gitignore" ) );
645 }
646 if ( file.getName().endsWith( "empty-directory-child" ) )
647 {
648 assertEquals( 1, file.list().length );
649 assertTrue( file.listFiles()[0].isDirectory() );
650 assertEquals( 1, file.listFiles()[0].listFiles().length );
651
652 assertTrue( file.listFiles()[0].listFiles()[0].getName().endsWith( ".gitignore" ) );
653 }
654 }
655 else
656 {
657 fail( "unknown child file found " + file.getName() );
658 }
659 }
660 }
661
662
663
664
665
666 private static void createTestDataStructure()
667 throws IOException
668 {
669 File sourceDirectory = new File( getBasedir(), "/target/sourceTestGitIgnoreFile" );
670 if ( sourceDirectory.exists() )
671 {
672 FileUtils.forceDelete( sourceDirectory );
673 }
674
675 File dir1 = new File( sourceDirectory, "dir1" );
676
677 dir1.mkdirs();
678 FileUtils.write( new File( dir1, "foo.txt" ), "This is a Test File", "UTF-8" );
679
680 File emptyDirectory = new File( sourceDirectory, "empty-directory" );
681 emptyDirectory.mkdirs();
682
683 FileUtils.write( new File( emptyDirectory, ".gitignore" ), "# .gitignore file", "UTF-8" );
684
685 File emptyDirectoryChild = new File( sourceDirectory, "empty-directory-child" );
686 emptyDirectory.mkdirs();
687
688 File emptyDirectoryChildEmptyChild = new File( emptyDirectoryChild, "empty-child" );
689 emptyDirectoryChildEmptyChild.mkdirs();
690
691 FileUtils.write( new File( emptyDirectoryChildEmptyChild, ".gitignore" ), "# .gitignore file", "UTF-8" );
692 }
693
694
695
696
697 @SuppressWarnings( "serial" )
698 public void testMSHARED81()
699 throws Exception
700 {
701 mavenProject.addProperty( "escaped", "this is escaped" );
702 mavenProject.addProperty( "escaped.at", "this is escaped.at" );
703 mavenProject.addProperty( "foo", "this is foo" );
704 mavenProject.addProperty( "bar", "this is bar" );
705
706
707 List<Resource> resources = new ArrayList<>();
708 resources.add( new Resource()
709 {
710 {
711 setDirectory( getBasedir() + "/src/test/units-files/MSHARED-81/resources" );
712 setFiltering( false );
713 }
714 } );
715 resources.add( new Resource()
716 {
717 {
718 setDirectory( getBasedir() + "/src/test/units-files/MSHARED-81/filtered" );
719 setFiltering( true );
720 }
721 } );
722 File output = new File( outputDirectory, "MSHARED-81" );
723 MavenResourcesExecution mavenResourcesExecution =
724 new MavenResourcesExecution( resources, output, mavenProject, "UTF-8", Collections.<String> emptyList(),
725 Collections.<String> emptyList(), new StubMavenSession() );
726 mavenResourcesExecution.setIncludeEmptyDirs( true );
727 mavenResourcesExecution.setEscapeString( "\\" );
728
729 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
730
731 Properties filteredResult = PropertyUtils.loadPropertyFile( new File( output, "filtered.properties" ), null );
732
733 Properties expectedFilteredResult =
734 PropertyUtils.loadPropertyFile( new File( getBasedir() + "/src/test/units-files/MSHARED-81",
735 "expected-filtered.properties" ),
736 null );
737
738 assertEquals( expectedFilteredResult, filteredResult );
739
740 Properties nonFilteredResult =
741 PropertyUtils.loadPropertyFile( new File( output, "unfiltered.properties" ), null );
742
743 Properties expectedNonFilteredResult =
744 PropertyUtils.loadPropertyFile( new File( getBasedir() + "/src/test/units-files/MSHARED-81/resources",
745 "unfiltered.properties" ),
746 null );
747
748 assertTrue( nonFilteredResult.equals( expectedNonFilteredResult ) );
749 }
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791 @SuppressWarnings( "serial" )
792 public void testEdgeCases()
793 throws Exception
794 {
795 mavenProject.addProperty( "escaped", "this is escaped" );
796 mavenProject.addProperty( "escaped.at", "this is escaped.at" );
797 mavenProject.addProperty( "foo", "this is foo" );
798 mavenProject.addProperty( "bar", "this is bar" );
799 mavenProject.addProperty( "domain", "this.is.domain.com" );
800
801
802 List<Resource> resources = new ArrayList<>();
803 resources.add( new Resource()
804 {
805 {
806 setDirectory( getBasedir() + "/src/test/units-files/edge-cases/resources" );
807 setFiltering( false );
808 }
809 } );
810 resources.add( new Resource()
811 {
812 {
813 setDirectory( getBasedir() + "/src/test/units-files/edge-cases/filtered" );
814 setFiltering( true );
815 }
816 } );
817 File output = new File( outputDirectory, "edge-cases" );
818 MavenResourcesExecution mavenResourcesExecution =
819 new MavenResourcesExecution( resources, output, mavenProject, "UTF-8", Collections.<String> emptyList(),
820 Collections.<String> emptyList(), new StubMavenSession() );
821 mavenResourcesExecution.setIncludeEmptyDirs( true );
822 mavenResourcesExecution.setEscapeString( "\\" );
823
824 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
825
826 Properties filteredResult = PropertyUtils.loadPropertyFile( new File( output, "filtered.properties" ), null );
827
828 Properties expectedFilteredResult =
829 PropertyUtils.loadPropertyFile( new File( getBasedir() + "/src/test/units-files/edge-cases",
830 "expected-filtered.properties" ),
831 null );
832
833 assertEquals( expectedFilteredResult, filteredResult );
834
835 Properties nonFilteredResult =
836 PropertyUtils.loadPropertyFile( new File( output, "unfiltered.properties" ), null );
837
838 Properties expectedNonFilteredResult =
839 PropertyUtils.loadPropertyFile( new File( getBasedir() + "/src/test/units-files/edge-cases/resources",
840 "unfiltered.properties" ),
841 null );
842
843 assertTrue( nonFilteredResult.equals( expectedNonFilteredResult ) );
844 }
845
846
847 public void testFilterFileName()
848 throws Exception
849 {
850
851 String unitFilesDir = getBasedir() + "/src/test/units-files/maven-filename-filtering";
852
853 Resource resource = new Resource();
854 resource.setDirectory( unitFilesDir );
855 resource.setFiltering( true );
856 resource.addInclude( "${pom.version}*" );
857 resource.setTargetPath( "testTargetPath" );
858
859 MavenResourcesExecution mavenResourcesExecution =
860 new MavenResourcesExecution( Collections.singletonList( resource ), outputDirectory, mavenProject, "UTF-8",
861 Collections.<String> emptyList(), Collections.<String> emptyList(),
862 new StubMavenSession() );
863 mavenResourcesExecution.setFilterFilenames( true );
864 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
865
866 File targetPathFile = new File( outputDirectory, "testTargetPath" );
867
868 File[] files = targetPathFile.listFiles();
869 assertEquals( 1, files.length );
870 assertEquals( "1.0.txt", files[0].getName() );
871 }
872
873
874
875
876 public void testFilterPropertiesFiles()
877 throws Exception
878 {
879
880 String unitFilesDir = getBasedir() + "/src/test/units-files/MRESOURCES-171";
881
882 Resource resource = new Resource();
883 resource.setDirectory( unitFilesDir );
884 resource.setFiltering( true );
885 resource.setTargetPath( "testFilterPropertiesFiles" );
886
887 MavenResourcesExecution mavenResourcesExecution =
888 new MavenResourcesExecution( Collections.singletonList( resource ), outputDirectory, mavenProject, "UTF-8",
889 Collections.<String> emptyList(), Collections.<String> emptyList(),
890 new StubMavenSession() );
891 mavenResourcesExecution.setPropertiesEncoding( "ISO-8859-1" );
892 mavenResourcesFiltering.filterResources( mavenResourcesExecution );
893
894 File targetPathFile = new File( outputDirectory, "testFilterPropertiesFiles" );
895 assertTrue( FileUtils.contentEquals( new File( unitFilesDir, "test.properties" ),
896 new File( targetPathFile, "test.properties" ) ) );
897 assertTrue( FileUtils.contentEquals( new File( unitFilesDir, "test.txt" ),
898 new File( targetPathFile, "test.txt" ) ) );
899 }
900
901 public void testGetEncoding()
902 {
903 File propertiesFile = new File( "file.properties" );
904 File regularFile = new File( "file.xml" );
905
906
907 assertEquals( null, DefaultMavenResourcesFiltering.getEncoding( propertiesFile, null, null ) );
908 assertEquals( "UTF-8", DefaultMavenResourcesFiltering.getEncoding( propertiesFile, "UTF-8", null ) );
909 assertEquals( "ISO-8859-1", DefaultMavenResourcesFiltering.getEncoding( propertiesFile, "UTF-8", "ISO-8859-1" ) );
910
911 assertEquals( null, DefaultMavenResourcesFiltering.getEncoding( regularFile, null, null ) );
912 assertEquals( "UTF-8", DefaultMavenResourcesFiltering.getEncoding( regularFile, "UTF-8", null ) );
913 assertEquals( "UTF-8", DefaultMavenResourcesFiltering.getEncoding( regularFile, "UTF-8", "ISO-8859-1" ) );
914 }
915
916 public void testIsPropertiesFile()
917 {
918
919 assertTrue( DefaultMavenResourcesFiltering.isPropertiesFile( new File( "file.properties" ) ) );
920 assertTrue( DefaultMavenResourcesFiltering.isPropertiesFile( new File( "some/parent/path",
921 "file.properties" ) ) );
922
923 assertFalse( DefaultMavenResourcesFiltering.isPropertiesFile( new File( "file" ) ) );
924 assertFalse( DefaultMavenResourcesFiltering.isPropertiesFile( new File( "some/parent/path", "file" ) ) );
925 assertFalse( DefaultMavenResourcesFiltering.isPropertiesFile( new File( "file.xml" ) ) );
926 assertFalse( DefaultMavenResourcesFiltering.isPropertiesFile( new File( "some/parent/path", "file.xml" ) ) );
927 }
928 }