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