Light, fluffy, and always free - The AWS Local Emulator alternative
chore(codeartifact): share the sidecar request-URI encoding helpers (#5026)
Priamo Germosenf8a721ce57db
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarManager.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarManager.javaindex 202405e200..2a420b9d4d 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarManager.java@@ -18,7 +18,6 @@ import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;import java.net.http.HttpResponse.BodyHandlers;-import java.nio.charset.StandardCharsets;import java.time.Duration;import java.util.List;import java.util.Locale;@@ -105,9 +104,10 @@ public class PypiserverSidecarManager implements RepositorySidecarManager, Conta* {@code assetName} itself embeds {@code version} the way every real PyPI filename does* (PEP 427/517 naming) rather than trusting the caller's {@code version} argument on its own.*- * <p>{@code assetName} is percent-encoded via {@link #encodeSegment} before joining it to- * the fixed {@code /packages/} prefix: without that, a {@code /} inside it would be- * indistinguishable from a real path separator and could splice in extra path segments.+ * <p>{@code assetName} is percent-encoded via {@link SidecarUriUtils#encodeSegment(String)}+ * before joining it to the fixed {@code /packages/} prefix: without that, a {@code /} inside+ * it would be indistinguishable from a real path separator and could splice in extra path+ * segments.*/@Overridepublic Optional<byte[]> fetchPackageVersionAsset(String repositoryContainerId, String domain, String repository,@@ -119,7 +119,7 @@ public class PypiserverSidecarManager implements RepositorySidecarManager, Contaif (!packageIndexListsAsset(baseUrl, packageName, assetName)) {return Optional.empty();}- URI uri = combine(URI.create(baseUrl), "/packages/" + encodeSegment(assetName));+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/packages/" + SidecarUriUtils.encodeSegment(assetName));HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(10)).GET().build();HttpResponse<byte[]> response;try {@@ -137,58 +137,6 @@ public class PypiserverSidecarManager implements RepositorySidecarManager, Contareturn Optional.of(response.body());}- /**- * Combines {@code base}'s scheme, authority, and own path prefix (this manager's own {@code- * baseUrl} is always a bare container address today with no path, but the sibling Reposilite- * client's equivalent helper does need this for its externally configurable URL, so this- * stays consistent with it) with an already percent-encoded {@code encodedPath}, built from- * {@link #encodeSegment}-encoded, caller-supplied segments. {@code encodedPath} must be fully- * encoded going in: this hands the combined string straight to {@link URI#create}, which- * only parses, rather than running it through a constructor that would try to quote it a- * second time and corrupt any {@code %} it finds (double-encoding, e.g. turning a deliberate- * {@code %2F} into {@code %252F}).- */- private static URI combine(URI base, String encodedPath) {- // getRawPath(), not getPath(): if baseUrl's own path carries any encoding, it must- // survive untouched rather than being decoded and re-encoded alongside the new path.- // getRawAuthority() below is the same reasoning applied to userinfo/host.- String prefix = base.getRawPath();- if (prefix == null || prefix.equals("/")) {- prefix = "";- } else if (prefix.endsWith("/")) {- prefix = prefix.substring(0, prefix.length() - 1);- }- return URI.create(base.getScheme() + "://" + base.getRawAuthority() + prefix + encodedPath);- }-- /**- * Percent-encodes a single untrusted path segment so it can never be mistaken for a- * structural separator or a dot-segment. Every byte outside the unreserved set is escaped,- * including {@code /} (otherwise legal inside a path, and so otherwise indistinguishable- * from one of the real separators this class inserts around it). A segment that is exactly- * {@code .} or {@code ..} gets its dots escaped too: those are themselves otherwise-legal- * unreserved characters, but a bare {@code ..} between two real {@code /} separators is a- * dot-segment that something in front of the sidecar could resolve by walking back out of- * the directory this method intends to confine the request to.- */- private static String encodeSegment(String segment) {- if (segment.equals(".") || segment.equals("..")) {- return segment.replace(".", "%2E");- }- StringBuilder encoded = new StringBuilder();- for (byte b : segment.getBytes(StandardCharsets.UTF_8)) {- int v = b & 0xFF;- char c = (char) v;- if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')- || c == '-' || c == '_' || c == '~' || c == '.') {- encoded.append(c);- } else {- encoded.append('%').append(String.format("%02X", v));- }- }- return encoded.toString();- }-/*** PEP 503 normalization: lowercase, runs of {@code -_.} collapsed to one {@code -}, same as* {@code CodeArtifactPypiController}'s own pre-upload index check. {@code -} and {@code _}@@ -202,7 +150,8 @@ public class PypiserverSidecarManager implements RepositorySidecarManager, Contaprivate boolean packageIndexListsAsset(String baseUrl, String packageName, String assetName) {String normalized = normalizePackageName(packageName);- URI uri = combine(URI.create(baseUrl), "/simple/" + encodeSegment(normalized) + "/");+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/simple/" + SidecarUriUtils.encodeSegment(normalized)+ + "/");HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(10)).GET().build();HttpResponse<String> response;try {diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.javaindex a22081221f..8f71961f65 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java@@ -17,7 +17,6 @@ import java.net.http.HttpRequest;import java.net.http.HttpRequest.BodyPublishers;import java.net.http.HttpResponse;import java.net.http.HttpResponse.BodyHandlers;-import java.nio.charset.StandardCharsets;import java.time.Duration;import java.util.Arrays;import java.util.Optional;@@ -94,23 +93,23 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {* them with {@code +} the way the wire-protocol route concatenates its one path would let a* {@code /} inside, say, {@code assetName} splice in extra path segments, or a value of* exactly {@code ..} walk back out of the version directory it's supposed to be confined to.- * Each coordinate is therefore percent-encoded on its own via {@link #encodeSegment}, which- * escapes both of those, before being joined with the real {@code /} separators this method- * supplies itself.+ * Each coordinate is therefore percent-encoded on its own via+ * {@link SidecarUriUtils#encodeSegment(String)}, which escapes both of those, before being+ * joined with the real {@code /} separators this method supplies itself.*/@Overridepublic Optional<byte[]> fetchPackageVersionAsset(String repositoryContainerId, String domain, String repository,String namespace, String packageName, String version, String assetName) {ensureRepository(repositoryContainerId);String baseUrl = manager.ensureReady();- StringBuilder path = new StringBuilder("/").append(encodeSegment(repositoryContainerId));+ StringBuilder path = new StringBuilder("/").append(SidecarUriUtils.encodeSegment(repositoryContainerId));for (String namespacePart : namespace.split("\\.", -1)) {- path.append('/').append(encodeSegment(namespacePart));+ path.append('/').append(SidecarUriUtils.encodeSegment(namespacePart));}- path.append('/').append(encodeSegment(packageName))- .append('/').append(encodeSegment(version))- .append('/').append(encodeSegment(assetName));- HttpRequest request = HttpRequest.newBuilder(combine(URI.create(baseUrl), path.toString()))+ path.append('/').append(SidecarUriUtils.encodeSegment(packageName))+ .append('/').append(SidecarUriUtils.encodeSegment(version))+ .append('/').append(SidecarUriUtils.encodeSegment(assetName));+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl), path.toString())).timeout(Duration.ofSeconds(30)).header("Authorization", manager.basicAuthHeader()).GET()@@ -437,64 +436,12 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {private static URI requestUri(String baseUrl, String path) {try {String encodedPath = new URI(null, null, path, null, null).getRawPath();- return combine(URI.create(baseUrl), encodedPath);+ return SidecarUriUtils.combine(URI.create(baseUrl), encodedPath);} catch (URISyntaxException e) {throw new IllegalStateException("Could not build a request URI for " + path, e);}}- /**- * Combines {@code base}'s scheme, authority, and own path prefix with an already- * percent-encoded {@code encodedPath}. {@code encodedPath} must be fully encoded going in:- * this method hands the combined string straight to {@link URI#create}, which only parses,- * rather than running it through a constructor that would try to quote it a second time and- * corrupt any {@code %} it finds (double-encoding, e.g. turning a deliberate {@code %2F} into- * {@code %252F}).- */- private static URI combine(URI base, String encodedPath) {- // getRawPath(), not getPath(): the configured prefix's own encoding (e.g. a literal %2F- // standing for an escaped slash within one opaque segment) must survive untouched. Decoding- // it and handing it to the URI constructor alongside the new path would re-encode the whole- // thing together and could turn that %2F into a literal /, changing what the prefix means to- // whatever sits in front of the sidecar. getRawAuthority() below is the same reasoning- // applied to userinfo/host, e.g. a percent-encoded character inside HTTP Basic credentials.- String prefix = base.getRawPath();- if (prefix == null || prefix.equals("/")) {- prefix = "";- } else if (prefix.endsWith("/")) {- prefix = prefix.substring(0, prefix.length() - 1);- }- return URI.create(base.getScheme() + "://" + base.getRawAuthority() + prefix + encodedPath);- }-- /**- * Percent-encodes a single untrusted path segment so it can never be mistaken for a- * structural separator or a dot-segment. Every byte outside the unreserved set is escaped,- * including {@code /} (which the generic path-quoting {@link URI} constructor otherwise- * leaves alone, since a real {@code /} is legal inside a path). A segment that is exactly- * {@code .} or {@code ..} gets its dots escaped too: those are themselves otherwise-legal- * unreserved characters, but a bare {@code ..} between two real {@code /} separators is a- * dot-segment that something in front of the sidecar could resolve by walking back out of- * the directory this method intends to confine the request to.- */- private static String encodeSegment(String segment) {- if (segment.equals(".") || segment.equals("..")) {- return segment.replace(".", "%2E");- }- StringBuilder encoded = new StringBuilder();- for (byte b : segment.getBytes(StandardCharsets.UTF_8)) {- int v = b & 0xFF;- char c = (char) v;- if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')- || c == '-' || c == '_' || c == '~' || c == '.') {- encoded.append(c);- } else {- encoded.append('%').append(String.format("%02X", v));- }- }- return encoded.toString();- }-private <T> HttpResponse<T> send(HttpRequest request, HttpResponse.BodyHandler<T> bodyHandler) {try {return httpClient.send(request, bodyHandler);diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/SidecarUriUtils.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/SidecarUriUtils.javanew file mode 100644index 0000000000..ad2541fa77--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/SidecarUriUtils.java@@ -0,0 +1,70 @@+package io.github.hectorvent.floci.services.codeartifact;++import java.net.URI;+import java.nio.charset.StandardCharsets;++/**+ * Shared URI-construction helpers for the Maven, npm, and pypi sidecar clients, each of which+ * builds a request URI out of its own {@code baseUrl} plus one or more caller-supplied path+ * segments (a repository id, package coordinates, an asset filename). Package-private: every+ * caller lives in this package, and {@link #combine} in particular requires its {@code+ * encodedPath} argument to already be fully percent-encoded, a precondition not worth exposing+ * to unrelated callers outside the three clients that know to uphold it.+ */+final class SidecarUriUtils {++ private SidecarUriUtils() {}++ /**+ * Combines {@code base}'s scheme, authority, and own path prefix with an already+ * percent-encoded {@code encodedPath}, built from {@link #encodeSegment}-encoded,+ * caller-supplied segments. {@code encodedPath} must be fully encoded going in: this hands+ * the combined string straight to {@link URI#create}, which only parses, rather than running+ * it through a constructor that would try to quote it a second time and corrupt any+ * {@code %} it finds (double-encoding, e.g. turning a deliberate {@code %2F} into+ * {@code %252F}).+ */+ static URI combine(URI base, String encodedPath) {+ // getRawPath(), not getPath(): the configured prefix's own encoding (e.g. a literal %2F+ // standing for an escaped slash within one opaque segment) must survive untouched. Decoding+ // it and handing it to the URI constructor alongside the new path would re-encode the whole+ // thing together and could turn that %2F into a literal /, changing what the prefix means to+ // whatever sits in front of the sidecar. getRawAuthority() below is the same reasoning+ // applied to userinfo/host, e.g. a percent-encoded character inside HTTP Basic credentials.+ String prefix = base.getRawPath();+ if (prefix == null || prefix.equals("/")) {+ prefix = "";+ } else if (prefix.endsWith("/")) {+ prefix = prefix.substring(0, prefix.length() - 1);+ }+ return URI.create(base.getScheme() + "://" + base.getRawAuthority() + prefix + encodedPath);+ }++ /**+ * Percent-encodes a single untrusted path segment so it can never be mistaken for a+ * structural separator or a dot-segment. Every byte outside the unreserved set is escaped,+ * including {@code /} (which the generic path-quoting {@link URI} constructor otherwise+ * leaves alone, since a real {@code /} is legal inside a path). A segment that is exactly+ * {@code .} or {@code ..} gets its dots escaped too: those are themselves otherwise-legal+ * unreserved characters, but a bare {@code ..} between two real {@code /} separators is a+ * dot-segment that something in front of the sidecar could resolve by walking back out of+ * the directory the caller intends to confine the request to.+ */+ static String encodeSegment(String segment) {+ if (segment.equals(".") || segment.equals("..")) {+ return segment.replace(".", "%2E");+ }+ StringBuilder encoded = new StringBuilder();+ for (byte b : segment.getBytes(StandardCharsets.UTF_8)) {+ int v = b & 0xFF;+ char c = (char) v;+ if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')+ || c == '-' || c == '_' || c == '~' || c == '.') {+ encoded.append(c);+ } else {+ encoded.append('%').append(String.format("%02X", v));+ }+ }+ return encoded.toString();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarManager.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarManager.javaindex c16acc5522..718d7a2223 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarManager.java@@ -144,10 +144,10 @@ public class VerdaccioSidecarManager implements RepositorySidecarManager, Contai* <p>{@code namespace}, {@code packageName}, and {@code assetName} are each their own* independently caller-supplied value, only meant to be one path segment; {@code* packagePath} and the final {@code /-/<assetName>} suffix supply the real {@code /}- * separators themselves, around each value already percent-encoded on its own via {@link- * #encodeSegment}. Without that, a {@code /} inside, say, {@code assetName} would be- * indistinguishable from one of those real separators and could splice in extra path- * segments.+ * separators themselves, around each value already percent-encoded on its own via+ * {@link SidecarUriUtils#encodeSegment(String)}. Without that, a {@code /} inside, say,+ * {@code assetName} would be indistinguishable from one of those real separators and could+ * splice in extra path segments.*/@Overridepublic Optional<byte[]> fetchPackageVersionAsset(String repositoryContainerId, String domain, String repository,@@ -158,7 +158,8 @@ public class VerdaccioSidecarManager implements RepositorySidecarManager, Contaiif (!versionHasAsset(baseUrl, packagePath, version, assetName)) {return Optional.empty();}- URI uri = combine(URI.create(baseUrl), "/" + packagePath + "/-/" + encodeSegment(assetName));+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/" + packagePath + "/-/"+ + SidecarUriUtils.encodeSegment(assetName));HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(10)).GET().build();HttpResponse<byte[]> response;try {@@ -178,12 +179,12 @@ public class VerdaccioSidecarManager implements RepositorySidecarManager, Contaiprivate static String packagePath(String namespace, String packageName) {return namespace == null- ? encodeSegment(packageName)- : "@" + encodeSegment(namespace) + "/" + encodeSegment(packageName);+ ? SidecarUriUtils.encodeSegment(packageName)+ : "@" + SidecarUriUtils.encodeSegment(namespace) + "/" + SidecarUriUtils.encodeSegment(packageName);}private boolean versionHasAsset(String baseUrl, String packagePath, String version, String assetName) {- HttpRequest request = HttpRequest.newBuilder(combine(URI.create(baseUrl), "/" + packagePath))+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl), "/" + packagePath)).timeout(Duration.ofSeconds(10)).GET().build();HttpResponse<String> response;try {@@ -212,60 +213,6 @@ public class VerdaccioSidecarManager implements RepositorySidecarManager, Contaireturn assetName.equals(tarballFilename);}- /**- * Combines {@code base}'s scheme, authority, and own path prefix (this manager's own {@code- * baseUrl} is always a bare container address today with no path, but the sibling Reposilite- * client's equivalent helper does need this for its externally configurable URL, so this- * stays consistent with it) with an already percent-encoded {@code encodedPath}, built from- * {@link #encodeSegment}-encoded, caller-supplied segments. {@code encodedPath} must be fully- * encoded going in: this hands the combined string straight to {@link URI#create}, which- * only parses, rather than running it through a constructor that would try to quote it a- * second time and corrupt any {@code %} it finds (double-encoding, e.g. turning a deliberate- * {@code %2F} into {@code %252F}).- */- private static URI combine(URI base, String encodedPath) {- // getRawPath(), not getPath(): if baseUrl's own path carries any encoding (an escaped- // slash within one opaque segment, say), it must survive untouched rather than being- // decoded and re-encoded alongside the new path, which could change what it means to- // whatever sits in front of the sidecar. getRawAuthority() below is the same reasoning- // applied to userinfo/host.- String prefix = base.getRawPath();- if (prefix == null || prefix.equals("/")) {- prefix = "";- } else if (prefix.endsWith("/")) {- prefix = prefix.substring(0, prefix.length() - 1);- }- return URI.create(base.getScheme() + "://" + base.getRawAuthority() + prefix + encodedPath);- }-- /**- * Percent-encodes a single untrusted path segment so it can never be mistaken for a- * structural separator or a dot-segment. Every byte outside the unreserved set is escaped,- * including {@code /} (otherwise legal inside a path, and so otherwise indistinguishable- * from one of the real separators this class inserts around it). A segment that is exactly- * {@code .} or {@code ..} gets its dots escaped too: those are themselves otherwise-legal- * unreserved characters, but a bare {@code ..} between two real {@code /} separators is a- * dot-segment that something in front of the sidecar could resolve by walking back out of- * the directory this method intends to confine the request to.- */- private static String encodeSegment(String segment) {- if (segment.equals(".") || segment.equals("..")) {- return segment.replace(".", "%2E");- }- StringBuilder encoded = new StringBuilder();- for (byte b : segment.getBytes(StandardCharsets.UTF_8)) {- int v = b & 0xFF;- char c = (char) v;- if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')- || c == '-' || c == '_' || c == '~' || c == '.') {- encoded.append(c);- } else {- encoded.append('%').append(String.format("%02X", v));- }- }- return encoded.toString();- }-private PerKeyContainerPool.StartedContainer startContainer(String npmRepositoryId, String publicUrl) {String image = config.services().codeartifact().npmImage();String containerName = ContainerStorageHelper.dockerName(config, "floci-verdaccio-" + npmRepositoryId);diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/SidecarUriUtilsTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/SidecarUriUtilsTest.javanew file mode 100644index 0000000000..07a84ef478--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/SidecarUriUtilsTest.java@@ -0,0 +1,89 @@+package io.github.hectorvent.floci.services.codeartifact;++import org.junit.jupiter.api.Test;++import java.net.URI;++import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.equalTo;++/**+ * Focused unit coverage for the helper all three sidecar clients (Maven, npm, pypi) depend on to+ * build their request URIs. The behavior-level regression tests for the real finding that+ * motivated this encoding (path traversal and URI-fragment/query injection via a caller-supplied+ * asset name) live in each client's own test, exercised through a live request path; this class+ * covers the shared helper in isolation.+ */+class SidecarUriUtilsTest {++ @Test+ void encodeSegmentLeavesUnreservedCharactersUntouched() {+ assertThat(SidecarUriUtils.encodeSegment("abcXYZ019-_~.jar"), equalTo("abcXYZ019-_~.jar"));+ }++ @Test+ void encodeSegmentEscapesASlashSoItCanNeverActAsAStructuralSeparator() {+ assertThat(SidecarUriUtils.encodeSegment("a/b"), equalTo("a%2Fb"));+ }++ @Test+ void encodeSegmentEscapesAPercentSoAnAlreadyEncodedLookingInputIsNotMistakenForOne() {+ assertThat(SidecarUriUtils.encodeSegment("100%done"), equalTo("100%25done"));+ }++ @Test+ void encodeSegmentEscapesASpaceAndOtherReservedCharacters() {+ assertThat(SidecarUriUtils.encodeSegment("a b#c?d"), equalTo("a%20b%23c%3Fd"));+ }++ @Test+ void encodeSegmentEscapesTheDotsOfABareSingleDotSegment() {+ assertThat(SidecarUriUtils.encodeSegment("."), equalTo("%2E"));+ }++ @Test+ void encodeSegmentEscapesTheDotsOfABareDoubleDotSegment() {+ assertThat(SidecarUriUtils.encodeSegment(".."), equalTo("%2E%2E"));+ }++ @Test+ void encodeSegmentLeavesDotsAloneWhenTheyAreNotTheWholeSegment() {+ assertThat(SidecarUriUtils.encodeSegment("1.0.1"), equalTo("1.0.1"));+ }++ @Test+ void combineAppendsTheEncodedPathToABareBaseUrl() {+ URI result = SidecarUriUtils.combine(URI.create("http://127.0.0.1:8080"), "/dom--repo/a-1.0.jar");++ assertThat(result, equalTo(URI.create("http://127.0.0.1:8080/dom--repo/a-1.0.jar")));+ }++ @Test+ void combinePreservesABaseUrlPathPrefix() {+ URI result = SidecarUriUtils.combine(URI.create("http://127.0.0.1:8080/reposilite"), "/dom--repo/a-1.0.jar");++ assertThat(result, equalTo(URI.create("http://127.0.0.1:8080/reposilite/dom--repo/a-1.0.jar")));+ }++ @Test+ void combineTrimsATrailingSlashFromTheBaseUrlPathPrefix() {+ URI result = SidecarUriUtils.combine(URI.create("http://127.0.0.1:8080/reposilite/"), "/dom--repo/a-1.0.jar");++ assertThat(result, equalTo(URI.create("http://127.0.0.1:8080/reposilite/dom--repo/a-1.0.jar")));+ }++ @Test+ void combinePreservesAPercentEncodedCharacterInTheBaseUrlPathPrefix() {+ URI result = SidecarUriUtils.combine(URI.create("http://127.0.0.1:8080/reposilite%2Fv1"),+ "/dom--repo/a-1.0.jar");++ assertThat(result.getRawPath(), equalTo("/reposilite%2Fv1/dom--repo/a-1.0.jar"));+ }++ @Test+ void combinePreservesAPercentEncodedCharacterInTheBaseUrlAuthority() {+ URI result = SidecarUriUtils.combine(URI.create("http://user%[email protected]"), "/dom--repo/a-1.0.jar");++ assertThat(result.getRawAuthority(), equalTo("user%[email protected]"));+ }+}