Pankraz76 commented on code in PR #2373:
URL: https://github.com/apache/maven/pull/2373#discussion_r2131971518
##########
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
+ PathTranslator mockPathTranslator = mock(PathTranslator.class);
+ UrlNormalizer mockUrlNormalizer = mock(UrlNormalizer.class);
+ RootLocator mockRootLocator = mock(RootLocator.class);
+ Interpolator mockInterpolator = mock(Interpolator.class);
+
+ // Create test instance with mocks
+ DefaultModelInterpolator interpolator =
+ new DefaultModelInterpolator(mockPathTranslator,
mockUrlNormalizer, mockRootLocator, mockInterpolator);
+
+ // Prepare test data
+ Path projectDir = Paths.get("/test/path");
+ ModelBuilderRequest request = ModelBuilderRequest.builder()
+ .session(session)
+ .requestType(ModelBuilderRequest.RequestType.BUILD_PROJECT)
+ .build();
+
+ // Test URL expressions that should be normalized
+ for (String urlExpression : URL_EXPRESSIONS) {
+ String testValue = "http://example.com/../test";
+ String expectedNormalized = "http://example.com/test";
+
+ // Configure mock to return normalized value
+
when(mockUrlNormalizer.normalize(testValue)).thenReturn(expectedNormalized);
+
+ // Call private method using reflection
+ Method postProcess =
DefaultModelInterpolator.class.getDeclaredMethod(
+ "postProcess", Path.class, ModelBuilderRequest.class,
String.class, String.class);
+ postProcess.setAccessible(true);
+
+ String result = (String) postProcess.invoke(interpolator,
projectDir, request, urlExpression, testValue);
+
+ assertEquals(expectedNormalized, result);
+ }
+
+ // Test non-URL expression that should NOT be normalized
+ String nonUrlExpression = "project.name";
+ String nonUrlValue = "http://example.com/../should-not-normalize";
+
+ Method postProcess = DefaultModelInterpolator.class.getDeclaredMethod(
+ "postProcess", Path.class, ModelBuilderRequest.class,
String.class, String.class);
+ postProcess.setAccessible(true);
+
+ String result = (String) postProcess.invoke(interpolator, projectDir,
request, nonUrlExpression, nonUrlValue);
+
+ // Verify normalization was NOT called
+ verify(mockUrlNormalizer, never()).normalize(nonUrlValue);
Review Comment:
idk if its any good, but its seems to be reflection of current coding,
therefore should be frozen with test, to be changed afterwards.
--
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]