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