Pankraz76 commented on code in PR #2373:
URL: https://github.com/apache/maven/pull/2373#discussion_r2131968639


##########
impl/maven-impl/src/test/java/org/apache/maven/impl/model/DefaultModelInterpolatorTest.java:
##########
@@ -592,4 +607,403 @@ public Path findMandatoryRoot(Path basedir) {
             }
         };
     }
+
+    @Test
+    @DisabledOnOs(WINDOWS)
+    void testProjectPropertyExtraction() throws Exception {
+        Path projectDir = Paths.get("/test/path");
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertEquals("/test/path", interpolator.projectProperty(model, 
projectDir, "basedir", false));
+        assertNull(interpolator.projectProperty(model, projectDir, 
"nonexistent.property", false));
+    }
+
+    @Test
+    @EnabledOnOs(WINDOWS)
+    void testProjectPropertyExtractionOnWindows() throws Exception {
+        Path projectDir = Paths.get("/test/path");
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertEquals("D:\\test\\path", interpolator.projectProperty(model, 
projectDir, "basedir", false));
+        assertNull(interpolator.projectProperty(model, projectDir, 
"nonexistent.property", false));
+    }
+
+    @Test
+    void testPathHandling() {
+        FileSystem fileSystem = Jimfs.newFileSystem(Configuration.windows());
+        Path projectDir = fileSystem.getPath("test/path");
+        Model model = Model.newBuilder()
+                .build(Build.newBuilder()
+                        .directory("${project.basedir}\\target")
+                        .build())
+                .build();
+        Model out = interpolator.interpolateModel(
+                model,
+                projectDir,
+                createModelBuildingRequest(Collections.emptyMap()).build(),
+                new SimpleProblemCollector());
+        assertEquals("C:\\work\\test\\path\\target", 
out.getBuild().getDirectory());
+    }
+
+    @Test
+    void testWindowsPathHandling() {
+        FileSystem fileSystem = Jimfs.newFileSystem(Configuration.windows());
+        Path projectDir = fileSystem.getPath("C:\\test\\path");
+        Model model = Model.newBuilder()
+                .build(Build.newBuilder()
+                        .directory("${project.basedir}\\target")
+                        .build())
+                .build();
+        Model out = interpolator.interpolateModel(
+                model,
+                projectDir,
+                createModelBuildingRequest(Collections.emptyMap()).build(),
+                new SimpleProblemCollector());
+        String expected = projectDir.resolve("target").toString();
+        assertEquals(expected, out.getBuild().getDirectory());
+    }
+
+    @Test
+    void testBasedirPropertyExtraction() throws Exception {
+        Path testDir = Paths.get("/test/path").toAbsolutePath();
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertEquals(testDir.toString(), interpolator.projectProperty(model, 
testDir, "basedir", false));
+    }
+
+    @Test
+    void testBasedirPrefixedPropertyExtraction() throws Exception {
+        Path testDir = Paths.get("/test/path").toAbsolutePath();
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertEquals(
+                testDir.getParent().toString(), 
interpolator.projectProperty(model, testDir, "basedir.parent", false));
+        assertEquals(
+                testDir.getFileName().toString(),
+                interpolator.projectProperty(model, testDir, 
"basedir.fileName", false));
+    }
+
+    @Test
+    void testBasedirPropertyWithNullProjectDir() throws Exception {
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertNull(interpolator.projectProperty(model, null, "basedir", 
false));
+        assertNull(interpolator.projectProperty(model, null, "basedir.any", 
false));
+    }
+
+    @Test
+    void testBaseUriPropertyExtraction() throws Exception {
+        Path testDir = Paths.get("/test/path").toAbsolutePath();
+        URI testUri = testDir.toUri();
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertEquals(testUri.toASCIIString(), 
interpolator.projectProperty(model, testDir, "baseUri", true));
+    }
+
+    @Test
+    void testBaseUriPropertyWithNullProjectDir() throws Exception {
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertNull(interpolator.projectProperty(model, null, "baseUri", true));
+        assertNull(interpolator.projectProperty(model, null, "baseUri.any", 
true));
+    }
+
+    @Test
+    void testBaseUriPropertyWithoutPrefix() throws Exception {
+        Path testDir = Paths.get("/test/path").toAbsolutePath();
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertNull(interpolator.projectProperty(model, testDir, "baseUri", 
false));
+        assertNull(interpolator.projectProperty(model, testDir, 
"baseUri.path", false));
+    }
+
+    @Test
+    void testBuildTimestampInterpolation() {
+        Map<String, String> props = new HashMap<>();
+        props.put("maven.build.timestamp.format", "yyyy-MM-dd");
+
+        Model model = Model.newBuilder().properties(props).build();
+        ModelBuilderRequest request = 
createModelBuildingRequest(Collections.emptyMap())
+                .session(session)
+                .build();
+
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+
+        String expectedDate = 
LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+
+        assertEquals(expectedDate, interpolator.doCallback(model, null, 
request, null, "build.timestamp"));
+        assertEquals(expectedDate, interpolator.doCallback(model, null, 
request, null, "maven.build.timestamp"));
+    }
+
+    @Test
+    void testBuildTimestampWithDefaultFormat() {
+        assertThat(Math.abs(Instant.parse(new DefaultModelInterpolator(
+                                                new DefaultPathTranslator(),
+                                                new DefaultUrlNormalizer(),
+                                                new DefaultRootLocator(),
+                                                new DefaultInterpolator())
+                                        .doCallback(
+                                                Model.newBuilder().build(),
+                                                null,
+                                                
createModelBuildingRequest(Collections.emptyMap())
+                                                        .session(session)
+                                                        .build(),
+                                                null,
+                                                "build.timestamp"))
+                                .getEpochSecond()
+                        - Instant.now().getEpochSecond()))
+                .isLessThan(3);
+    }
+
+    @Test
+    void testNonTimestampExpressions() {
+        Model model = Model.newBuilder().build();
+        ModelBuilderRequest request = 
createModelBuildingRequest(Collections.emptyMap())
+                .session(session)
+                .build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+        assertNull(interpolator.doCallback(model, null, request, null, 
"not.a.timestamp"));
+        assertNull(interpolator.doCallback(model, null, request, null, 
"build.something.else"));
+    }
+
+    @Test
+    void testBaseUriPropertyExtractionWithReflection() throws Exception {
+        Path testDir = Paths.get("/test/path").toAbsolutePath();
+        URI testUri = testDir.toUri();
+
+        Model model = Model.newBuilder().build();
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+
+        // Test direct baseUri access
+        assertEquals(testUri.toASCIIString(), 
interpolator.projectProperty(model, testDir, "baseUri", true));
+
+        // Test URI path component
+        assertEquals(testUri.getPath(), interpolator.projectProperty(model, 
testDir, "baseUri.path", true));
+
+        // Test URI scheme component
+        assertEquals(testUri.getScheme(), interpolator.projectProperty(model, 
testDir, "baseUri.scheme", true));
+
+        // Test URI host component
+        assertEquals(testUri.getHost(), interpolator.projectProperty(model, 
testDir, "baseUri.host", true));
+
+        // Test non-existent URI property
+        assertNull(interpolator.projectProperty(model, testDir, 
"baseUri.nonexistent", true));
+
+        // Test with null project directory
+        assertNull(interpolator.projectProperty(model, null, "baseUri.path", 
true));
+    }
+
+    @Test
+    void testUrlNormalizationThroughInterpolation() {
+        // Setup
+        DefaultUrlNormalizer urlNormalizer = new DefaultUrlNormalizer();
+        DefaultPathTranslator pathTranslator = new DefaultPathTranslator();
+        DefaultRootLocator rootLocator = new DefaultRootLocator();
+        DefaultInterpolator interpolator = new DefaultInterpolator();
+
+        DefaultModelInterpolator modelInterpolator =
+                new DefaultModelInterpolator(pathTranslator, urlNormalizer, 
rootLocator, interpolator);
+
+        Path projectDir = Paths.get("/test/path");
+        ModelBuilderRequest request = ModelBuilderRequest.builder()
+                .session(session)
+                .requestType(BUILD_PROJECT)
+                .build();
+
+        SimpleProblemCollector problems = new SimpleProblemCollector();
+
+        // Test project.url normalization
+        Model urlModel = 
Model.newBuilder().url("http://example.com/../path";).build();
+        Model interpolatedUrlModel = 
modelInterpolator.interpolateModel(urlModel, projectDir, request, problems);
+        assertEquals("http://example.com/../path";, 
interpolatedUrlModel.getUrl());
+
+        // Test project.scm.url normalization
+        Model scmModel = Model.newBuilder()
+                
.scm(Scm.newBuilder().url("http://example.com/scm/../path";).build())
+                .build();
+        Model interpolatedScmModel = 
modelInterpolator.interpolateModel(scmModel, projectDir, request, problems);
+        assertEquals(
+                "http://example.com/scm/../path";, 
interpolatedScmModel.getScm().getUrl());
+
+        // Test project.scm.connection normalization
+        Model scmConnectionModel = Model.newBuilder()
+                .scm(Scm.newBuilder()
+                        
.connection("scm:git:http://example.com/repo/../path.git";)
+                        .build())
+                .build();
+        Model interpolatedScmConnectionModel =
+                modelInterpolator.interpolateModel(scmConnectionModel, 
projectDir, request, problems);
+        assertEquals(
+                "scm:git:http://example.com/repo/../path.git";,
+                interpolatedScmConnectionModel.getScm().getConnection());
+
+        // Test project.distributionManagement.site.url normalization
+        Model siteModel = Model.newBuilder()
+                .distributionManagement(DistributionManagement.newBuilder()
+                        .site(Site.newBuilder()
+                                .url("http://example.com/site/../path";)
+                                .build())
+                        .build())
+                .build();
+        Model interpolatedSiteModel = 
modelInterpolator.interpolateModel(siteModel, projectDir, request, problems);
+        assertEquals(
+                "http://example.com/site/../path";,
+                
interpolatedSiteModel.getDistributionManagement().getSite().getUrl());
+
+        // Verify no problems were reported
+        assertTrue(problems.getErrors().isEmpty());
+        assertTrue(problems.getWarnings().isEmpty());
+        assertTrue(problems.getFatals().isEmpty());
+    }
+
+    @Test
+    void testProjectPrefixes31Interpolation() {
+        // Setup
+        DefaultModelInterpolator interpolator = new DefaultModelInterpolator(
+                new DefaultPathTranslator(),
+                new DefaultUrlNormalizer(),
+                new DefaultRootLocator(),
+                new DefaultInterpolator());
+
+        Path projectDir = Paths.get("/test/path");
+
+        // Create request with RequestType that should use PROJECT_PREFIXES_3_1
+        ModelBuilderRequest request = ModelBuilderRequest.builder()
+                .session(session)
+                .requestType(ModelBuilderRequest.RequestType.BUILD_CONSUMER) 
// Use PROJECT instead of OTHER
+                .build();
+
+        SimpleProblemCollector problems = new SimpleProblemCollector();
+
+        // Create model with properties to test both pom. and project. prefixes
+        Model model = Model.newBuilder()
+                .version("1.0")
+                .artifactId("test-artifact")
+                .properties(Map.of(
+                        "testProp", "${pom.version}",
+                        "testProp2", "${project.version}",
+                        "testProp3", "${pom.artifactId}",
+                        "testProp4", "${project.artifactId}"))
+                .build();
+
+        // Execute interpolation
+        Model result = interpolator.interpolateModel(model, projectDir, 
request, problems);
+
+        // Verify both pom. and project. prefixes work
+        assertEquals("1.0", result.getProperties().get("testProp"));
+        assertEquals("1.0", result.getProperties().get("testProp2"));
+        assertEquals("test-artifact", result.getProperties().get("testProp3"));
+        assertEquals("test-artifact", result.getProperties().get("testProp4"));
+
+        // Verify no problems were reported
+        assertTrue(problems.getErrors().isEmpty());
+        assertTrue(problems.getWarnings().isEmpty());
+        assertTrue(problems.getFatals().isEmpty());
+
+        // Verify the correct prefixes list is used
+        assertEquals(Arrays.asList("pom.", "project."), 
interpolator.getProjectPrefixes(request));
+    }
+
+    private static final Set<String> URL_EXPRESSIONS = Set.of(
+            "project.url",
+            "project.scm.url",
+            "project.scm.connection",
+            "project.scm.developerConnection",
+            "project.distributionManagement.site.url");
+
+    @Test
+    void testUrlNormalizationInPostProcess() throws Exception {
+        // Create mock objects

Review Comment:
   yes thx done.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to