Refactor URI normalization: rename method for clarity, enhance exception handling, and update references in tests and implementations

Author: predic8

core/src/main/java/com/predic8/membrane/core/interceptor/server/WSDLPublisherInterceptor.java

@@ -234,7 +234,7 @@ private Outcome handleRequestInternal(final Exchange exc) throws Exception {
                 return RETURN;
             }
         } catch (NumberFormatException e) {
-            exc.setResponse(HttpUtil.setHTMLErrorResponse(Response.internalServerError(), "Bad parameter format.", ""));
+            exc.setResponse(HttpUtil.setHTMLErrorResponse(Response.badRequest(), "Bad parameter format.", ""));
             return ABORT;
         } catch (ResourceRetrievalException e) {
             exc.setResponse(notFound().build());

core/src/main/java/com/predic8/membrane/core/util/URIUtil.java

@@ -140,16 +140,17 @@ public static String normalizeSingleDot(String uri) {
     }
 
     /**
-     * Normalizes the given path or URI. This method handles various formats of paths,
+     * Normalizes the given path or URI and resolves it to an absolute path.
+     * This method handles various formats of paths,
      * including filesystem paths, URIs, and paths with potential Windows drive letters.
      * The normalization involves resolving relative components, such as "." or "..",
      * and ensuring the path conforms to a standardized format.
      *
-     * @param location the path or URI string to normalize. It must not be null or empty.
-     * @return the normalized path or URI as a string.
-     * @throws IllegalArgumentException if the input location is null or empty.
+     * @param location the path or URI string to normalize.
+     * @return the normalized absolute path or URI as a string.
+     * @throws IllegalArgumentException if the input location is null, empty, or contains malformed URI syntax.
      */
-    public static String normalize(String location) {
+    public static String getNormalizedAbsolutePathOrUri(String location) {
         if (location == null || location.isEmpty())
             throw new IllegalArgumentException("location must not be null or empty");
 

core/src/main/java/com/predic8/membrane/core/util/wsdl/parser/schema/AbstractIncludeImport.java

@@ -52,7 +52,7 @@ protected Schema getSchema(WSDLParserContext ctx) {
     }
 
     private String resolve(WSDLParserContext ctx) {
-        return URIUtil.normalize(ResolverMap.combine(ctx.basePath(), schemaLocation));
+        return URIUtil.getNormalizedAbsolutePathOrUri(ResolverMap.combine(ctx.basePath(), schemaLocation));
     }
 
     public String getSchemaLocation() {

core/src/test/java/com/predic8/membrane/core/util/URIUtilTest.java

@@ -215,94 +215,101 @@ void convertPath2FileURITest() throws URISyntaxException {
     class normalize {
         @Test
         void throwsOnNull() {
-            assertThrows(IllegalArgumentException.class, () -> normalize(null));
+            assertThrows(IllegalArgumentException.class, () -> getNormalizedAbsolutePathOrUri(null));
         }
 
+
         @Test
         void throwsOnEmpty() {
-            assertThrows(IllegalArgumentException.class, () -> normalize(""));
+            assertThrows(IllegalArgumentException.class, () -> getNormalizedAbsolutePathOrUri(""));
         }
 
         @Test
         void normalizesRelativeFilesystemPath() {
             var input = "foo/../bar/test.txt";
             var expected = Path.of(input).toAbsolutePath().normalize().toString();
-            assertEquals(expected, normalize(input));
+            assertEquals(expected, getNormalizedAbsolutePathOrUri(input));
         }
 
         @Test
         void normalizesAbsoluteFilesystemPath() {
             var input = Path.of("foo", "..", "bar").toAbsolutePath().toString();
             var expected = Path.of(input).toAbsolutePath().normalize().toString();
-            assertEquals(expected, normalize(input));
+            assertEquals(expected, getNormalizedAbsolutePathOrUri(input));
         }
 
         @Test
         void normalizesFileUri() {
-            assertEquals("file:/test.xml", normalize("file:///tmp/../test.xml"));
+            assertEquals("file:/test.xml", getNormalizedAbsolutePathOrUri("file:///tmp/../test.xml"));
         }
 
         @Test
         void normalizesHttpUri() {
-            assertEquals("http://example.com/b/wsdl.xsd", normalize("http://example.com/a/../b/wsdl.xsd"));
+            assertEquals("http://example.com/b/wsdl.xsd", getNormalizedAbsolutePathOrUri("http://example.com/a/../b/wsdl.xsd"));
         }
 
+        @Test
+        void normalizesHttpUriWithQuery() {
+            assertEquals("http://example.com/b/wsdl.xsd?a=a/../b", getNormalizedAbsolutePathOrUri("http://example.com/a/../b/wsdl.xsd?a=a/../b"));
+        }
+
+
         @Test
         void classpathUri() {
             // The '..' within the path portion normalizes correctly.
-            assertEquals("classpath://authority/xsd/test.xsd", normalize("classpath://authority/schema/../xsd/test.xsd"));
+            assertEquals("classpath://authority/xsd/test.xsd", getNormalizedAbsolutePathOrUri("classpath://authority/schema/../xsd/test.xsd"));
         }
 
         @Test
         void keepsClasspathUri() {
             // The '..' at the start of the path (after authority) cannot traverse above the authority, so it's preserved.
-            assertEquals("classpath://authority/../xsd/test.xsd", normalize("classpath://authority/../xsd/test.xsd"));
+            assertEquals("classpath://authority/../xsd/test.xsd", getNormalizedAbsolutePathOrUri("classpath://authority/../xsd/test.xsd"));
         }
 
         @Test
         void normalizesUnixLikePath() {
             var input = "/tmp/../var/data.xsd";
             var expected = Path.of(input).toAbsolutePath().normalize().toString();
-            assertEquals(expected, normalize(input));
+            assertEquals(expected, getNormalizedAbsolutePathOrUri(input));
         }
 
         @Test
         @EnabledOnOs(WINDOWS)
         void handlesWindowsDriveLetterPath() {
             var input = "C:\\temp\\..\\data\\test.xsd";
             var expected = Path.of(input).toAbsolutePath().normalize().toString();
-            assertEquals(expected, normalize(input));
+            assertEquals(expected, getNormalizedAbsolutePathOrUri(input));
         }
 
         @Test
         @EnabledOnOs(WINDOWS)
         void handlesWindowsDriveRelativePath() {
             var input = "C:temp\\..\\data\\test.xsd";
             var expected = Path.of(input).toAbsolutePath().normalize().toString();
-            assertEquals(expected, normalize(input));
+            assertEquals(expected, getNormalizedAbsolutePathOrUri(input));
         }
 
         @Test
         void keepsRelativeUriWithQuery() {
-            assertEquals("schema.xsd?version=1", normalize("schema.xsd?version=1")
+            assertEquals("schema.xsd?version=1", getNormalizedAbsolutePathOrUri("schema.xsd?version=1")
             );
         }
 
         @Test
         void keepsRelativeUriWithFragment() {
-            assertEquals("../types.xsd#frag", normalize("../types.xsd#frag")
+            assertEquals("../types.xsd#frag", getNormalizedAbsolutePathOrUri("../types.xsd#frag")
             );
         }
 
         @Test
         void keepsRelativeUriWithQueryAndFragment() {
-            assertEquals("../types.xsd?version=1#frag", normalize("../types.xsd?version=1#frag")
+            assertEquals("../types.xsd?version=1#frag", getNormalizedAbsolutePathOrUri("../types.xsd?version=1#frag")
             );
         }
 
         @Test
         void keepsSchemeRelativeReference() {
-            assertEquals("//example.com/schema.xsd?version=1", normalize("//example.com/schema.xsd?version=1"));
+            assertEquals("//example.com/schema.xsd?version=1", getNormalizedAbsolutePathOrUri("//example.com/schema.xsd?version=1"));
         }
     }
 }