You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sling.apache.org by gh...@apache.org on 2020/09/18 08:41:36 UTC
[sling-org-apache-sling-api] 01/01: SLING-9745 Introduce
ResourceUri (immutable) and ResourceUriBuilder
This is an automated email from the ASF dual-hosted git repository.
ghenzler pushed a commit to branch feature/SLING-9745-ResourceUri-Api
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-api.git
commit 298ed530c6bbd6bcc828c1c9c80790d9919c7f43
Author: georg.henzler <ge...@netcentric.biz>
AuthorDate: Fri Sep 18 10:41:15 2020 +0200
SLING-9745 Introduce ResourceUri (immutable) and ResourceUriBuilder
General purpose class to represent a ResourceUri (like e.g. a link in an
html <a> tag)
---
pom.xml | 1 -
.../apache/sling/api/resource/uri/ResourceUri.java | 181 +++++
.../sling/api/resource/uri/ResourceUriBuilder.java | 837 +++++++++++++++++++++
.../sling/api/resource/uri/package-info.java | 23 +
.../api/resource/uri/ResourceUriBuilderTest.java | 157 ++++
.../ResourceUriBuilderWithAdjustMethodTest.java | 244 ++++++
.../api/resource/uri/ResourceUriRebaseTest.java | 231 ++++++
.../sling/api/resource/uri/ResourceUriTest.java | 442 +++++++++++
...UriToSlingRequestPathInfoCompatibilityTest.java | 272 +++++++
9 files changed, 2387 insertions(+), 1 deletion(-)
diff --git a/pom.xml b/pom.xml
index 8e02cb7..38e6e92 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,7 +105,6 @@
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.2</version>
- <scope>test</scope>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
diff --git a/src/main/java/org/apache/sling/api/resource/uri/ResourceUri.java b/src/main/java/org/apache/sling/api/resource/uri/ResourceUri.java
new file mode 100644
index 0000000..1250215
--- /dev/null
+++ b/src/main/java/org/apache/sling/api/resource/uri/ResourceUri.java
@@ -0,0 +1,181 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.api.resource.uri;
+
+import static org.apache.commons.lang3.StringUtils.isBlank;
+import static org.apache.commons.lang3.StringUtils.isNotBlank;
+
+import java.net.URI;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import org.apache.sling.api.request.RequestPathInfo;
+import org.apache.sling.api.resource.Resource;
+
+/**
+ * Represents an immutable URI that points to a resource or alternatively, can contain opaque URIs like {@code mailto:} or
+ * {@code javascript:}. Use {@link ResourceUri#adjust(Consumer)} or {@link ResourceUriBuilder} to create new or modified instances.
+ */
+public interface ResourceUri extends RequestPathInfo {
+
+ /**
+ * @return returns the URI.
+ */
+ public URI toUri();
+
+ /**
+ * @return returns the URI as String.
+ */
+ public String toString();
+
+ /**
+ * @return returns the scheme of the ResourceUri or null if not set
+ */
+ public String getScheme();
+
+ /**
+ * @return returns the user info of the ResourceUri or null if not set
+ */
+ public String getUserInfo();
+
+ /**
+ * @return returns the host of the ResourceUri or null if not set
+ */
+ public String getHost();
+
+ /**
+ * @return returns the port of the ResourceUri or null if not set
+ */
+ public int getPort();
+
+ /**
+ * @return returns the resource path or null if the URI does not contain a path.
+ */
+ @Override
+ public String getResourcePath();
+
+ /**
+ * @return returns the selector string or null if the URI does not contain selector(s)
+ */
+ @Override
+ public String getSelectorString();
+
+ /**
+ * @return returns the selector array (empty if the URI does not contain selector(s))
+ */
+ @Override
+ public String[] getSelectors();
+
+ /**
+ * @return returns the extension or null if the URI does not contain an extension
+ */
+ @Override
+ public String getExtension();
+
+ /**
+ * @return returns the path parameters or an empty Map if the URI does not contain any
+ */
+ public Map<String, String> getPathParameters();
+
+ /**
+ * @return returns the suffix or null if the URI does not contain a suffix
+ */
+ @Override
+ public String getSuffix();
+
+ /**
+ * @return returns the joint path of resource path, selectors, extension and suffix or null if resource path is not set
+ */
+ public String getPath();
+
+ /**
+ * @return returns the query part of the uri
+ */
+ public String getQuery();
+
+ /**
+ * @return returns the url fragment of the uri
+ */
+ public String getFragment();
+
+ /**
+ * @return scheme specific part of the URI
+ */
+ public String getSchemeSpecificPart();
+
+ /**
+ * @return returns the corresponding suffix resource
+ */
+ @Override
+ public Resource getSuffixResource();
+
+ /**
+ * @return returns true if the uri is either a relative or absolute path (this is the case if scheme and host is empty and the URI path
+ * is set)
+ */
+ default boolean isPath() {
+ return isBlank(getScheme())
+ && isBlank(getHost())
+ && isNotBlank(getResourcePath());
+ }
+
+ /**
+ * @return true if the uri is a absolute path starting with a slash ('/'). This is the default case for all links to pages and assets in
+ * AEM.
+ */
+ default boolean isAbsolutePath() {
+ return isPath() && getResourcePath().startsWith(ResourceUriBuilder.CHAR_SLASH);
+ }
+
+ /**
+ * @return true if uri is relative (not an URL and not starting with '/')
+ */
+ default boolean isRelativePath() {
+ return isPath() && !getResourcePath().startsWith(ResourceUriBuilder.CHAR_SLASH);
+ }
+
+ /**
+ * @return true if the uri is an absolute URI containing a scheme.
+ */
+ default boolean isFullUri() {
+ return isNotBlank(getScheme())
+ && isNotBlank(getHost());
+ }
+
+ /**
+ * @return true if the uri is an opaque URI like e.g. mailto:
+ */
+ default boolean isOpaque() {
+ return isNotBlank(getScheme())
+ && isNotBlank(getSchemeSpecificPart());
+ }
+
+ /**
+ * Shortcut to adjust resource URIs, e.g. {@code resourceUri = resourceUri.adjust(b -> b.setExtension("html")); }.
+ *
+ * @param builderConsumer
+ * @return the adjusted ResourceUri (new instance)
+ */
+ default ResourceUri adjust(Consumer<ResourceUriBuilder> builderConsumer) {
+ ResourceUriBuilder builder = ResourceUriBuilder.createFrom(this);
+ builderConsumer.accept(builder);
+ return builder.build();
+ }
+
+}
diff --git a/src/main/java/org/apache/sling/api/resource/uri/ResourceUriBuilder.java b/src/main/java/org/apache/sling/api/resource/uri/ResourceUriBuilder.java
new file mode 100644
index 0000000..09e5d93
--- /dev/null
+++ b/src/main/java/org/apache/sling/api/resource/uri/ResourceUriBuilder.java
@@ -0,0 +1,837 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.api.resource.uri;
+
+import static org.apache.commons.lang3.StringUtils.isNotBlank;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.sling.api.SlingHttpServletRequest;
+import org.apache.sling.api.request.RequestPathInfo;
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Builder for ResourceUris.
+ */
+public class ResourceUriBuilder {
+
+ private static final String HTTPS_SCHEME = "https";
+ private static final int HTTPS_DEFAULT_PORT = 443;
+ private static final String HTTP_SCHEME = "http";
+ private static final int HTTP_DEFAULT_PORT = 80;
+
+ static final String CHAR_HASH = "#";
+ static final String CHAR_QM = "?";
+ static final String CHAR_DOT = ".";
+ static final String CHAR_SLASH = "/";
+ static final String CHAR_AT = "@";
+ static final String SELECTOR_DOT_REGEX = "\\.(?!\\.?/)"; // (?!\\.?/) to avoid matching ./ and ../
+ static final String CHAR_COLON = ":";
+ static final String CHAR_SEMICOLON = ";";
+ static final String CHAR_EQUALS = "=";
+ static final String CHAR_SINGLEQUOTE = "'";
+ static final String PATH_PARAMETERS_REGEX = ";([a-zA-z0-9]+)=(?:\\'([^']*)\\'|([^/]+))";
+
+ public static ResourceUriBuilder create() {
+ return new ResourceUriBuilder();
+ }
+
+ /**
+ * Creates a builder from another ResourceUri.
+ *
+ * @param resourceUri
+ * @return a ResourceUriBuilder
+ */
+ public static ResourceUriBuilder createFrom(ResourceUri resourceUri) {
+ return create()
+ .setScheme(resourceUri.getScheme())
+ .setUserInfo(resourceUri.getUserInfo())
+ .setHost(resourceUri.getHost())
+ .setPort(resourceUri.getPort())
+ .setResourcePath(resourceUri.getResourcePath())
+ .setPathParameters(resourceUri.getPathParameters())
+ .setSelectors(resourceUri.getSelectors())
+ .setExtension(resourceUri.getExtension())
+ .setSuffix(resourceUri.getSuffix())
+ .setQuery(resourceUri.getQuery())
+ .setFragment(resourceUri.getFragment())
+ .setSchemeSpecificPart(resourceUri.getSchemeSpecificPart())
+ .setResourceResolver(resourceUri instanceof ImmutableResourceUri
+ ? ((ImmutableResourceUri) resourceUri).getBuilder().resourceResolver
+ : null);
+ }
+
+ /**
+ * Creates a builder from a Resource (only taking the resource path into account).
+ *
+ * @param resource
+ * @return a ResourceUriBuilder
+ */
+ public static ResourceUriBuilder createFrom(Resource resource) {
+ return create()
+ .setResourcePath(resource.getPath())
+ .setResourceResolver(resource.getResourceResolver());
+ }
+
+ /**
+ * Creates a builder from a RequestPathInfo instance .
+ *
+ * @param requestPathInfo
+ * @return a ResourceUriBuilder
+ */
+ public static ResourceUriBuilder createFrom(RequestPathInfo requestPathInfo) {
+ Resource suffixResource = requestPathInfo.getSuffixResource();
+ return create()
+ .setResourceResolver(suffixResource != null ? suffixResource.getResourceResolver() : null)
+ .setResourcePath(requestPathInfo.getResourcePath())
+ .setSelectors(requestPathInfo.getSelectors())
+ .setExtension(requestPathInfo.getExtension())
+ .setSuffix(requestPathInfo.getSuffix());
+ }
+
+ /**
+ * Creates a builder from a request.
+ *
+ * @param request
+ * @return a ResourceUriBuilder
+ */
+ public static ResourceUriBuilder createFrom(SlingHttpServletRequest request) {
+ return createFrom(request.getRequestPathInfo())
+ .setResourceResolver(request.getResourceResolver())
+ .setScheme(request.getScheme())
+ .setHost(request.getServerName())
+ .setPort(request.getServerPort())
+ .setQuery(request.getQueryString());
+ }
+
+ /**
+ * Creates a builder from an arbitrary URI.
+ *
+ * @param uri
+ * the uri to transform to a ResourceUri
+ * @param resourceResolver
+ * a resource resolver is needed to decide up to what part the path is the resource path (that decision is only possible by
+ * checking against the underlying repository). If null is passed in, the shortest viable resource path is used.
+ * @return a ResourceUriBuilder
+ */
+ public static ResourceUriBuilder createFrom(@NotNull URI uri, @Nullable ResourceResolver resourceResolver) {
+ String path = uri.getPath();
+ boolean pathExists = !StringUtils.isBlank(path);
+ boolean schemeSpecificRelevant = !pathExists && uri.getQuery() == null;
+ return create()
+ .setResourceResolver(resourceResolver)
+ .setScheme(uri.getScheme())
+ .setUserInfo(uri.getUserInfo())
+ .setHost(uri.getHost())
+ .setPort(uri.getPort())
+ .setPath(pathExists ? path : null)
+ .setQuery(uri.getQuery())
+ .setFragment(uri.getFragment())
+ .setSchemeSpecificPart(schemeSpecificRelevant ? uri.getSchemeSpecificPart() : null);
+ }
+
+ /**
+ * Creates a builder from an arbitrary URI string.
+ *
+ * @param uriStr
+ * to uri string to parse
+ * @param resourceResolver
+ * a resource resolver is needed to decide up to what part the path is the resource path (that decision is only possible by
+ * checking against the underlying repository). If null is passed in, the shortest viable resource path is used.
+ * @return a ResourceUriBuilder
+ */
+ public static ResourceUriBuilder parse(@NotNull String uriStr, @Nullable ResourceResolver resourceResolver) {
+ URI uri;
+ try {
+ uri = new URI(uriStr);
+ return createFrom(uri, resourceResolver);
+ } catch (URISyntaxException e) {
+ throw new IllegalArgumentException("Invalid URI " + uriStr + ": " + e.getMessage(), e);
+ }
+ }
+
+ private String scheme = null;
+
+ private String userInfo = null;
+ private String host = null;
+ private int port = -1;
+
+ private String resourcePath = null;
+ private final List<String> selectors = new LinkedList<>();
+ private String extension = null;
+ private final Map<String, String> pathParameters = new LinkedHashMap<>();
+ private String suffix = null;
+ private String schemeSpecificPart = null;
+ private String query = null;
+ private String fragment = null;
+
+ // only needed for getSuffixResource() from interface RequestPathInfo
+ private ResourceResolver resourceResolver = null;
+
+ private ResourceUriBuilder() {
+ }
+
+ /** @param userInfo
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setUserInfo(String userInfo) {
+ if (schemeSpecificPart != null) {
+ return this;
+ }
+ this.userInfo = userInfo;
+ return this;
+ }
+
+ /** @param host
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setHost(String host) {
+ if (schemeSpecificPart != null) {
+ return this;
+ }
+ this.host = host;
+ return this;
+ }
+
+ /** @param port
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setPort(int port) {
+ if (schemeSpecificPart != null) {
+ return this;
+ }
+ this.port = port;
+ return this;
+ }
+
+ /** @param path
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setPath(String path) {
+ if (schemeSpecificPart != null) {
+ return this;
+ }
+
+ // adds path parameters to this.pathParameters and returns path without those
+ path = extractPathParameters(path);
+
+ // split in resource path, selectors, extension and suffix
+ Matcher dotMatcher;
+ if (path != null && path.startsWith(ResourceUriBuilder.CHAR_SLASH) && resourceResolver != null) {
+ setResourcePath(path);
+ rebaseResourcePath();
+ } else if (path != null && (dotMatcher = Pattern.compile(SELECTOR_DOT_REGEX).matcher(path)).find()) {
+ int firstDotPosition = dotMatcher.start();
+ setPathWithDefinedResourcePosition(path, firstDotPosition);
+ } else {
+ setResourcePath(path);
+ }
+
+ return this;
+ }
+
+ /**
+ * Will rebase the uri based on the underlying resource structure. A resource resolver is necessary for this operation, hence
+ * setResourceResolver() needs to be called before balanceResourcePath() or a create method that implicitly sets this has to be used.
+ *
+ * @return the builder for method chaining
+ * @throws IllegalStateException
+ * if no resource resolver is available
+ */
+ public ResourceUriBuilder rebaseResourcePath() {
+ if (schemeSpecificPart != null || resourcePath == null) {
+ return this;
+ }
+ if (resourceResolver == null) {
+ throw new IllegalStateException("setResourceResolver() needs to be called before balanceResourcePath()");
+ }
+
+ String path = assemblePath(false);
+ ResourcePathIterator it = new ResourcePathIterator(path);
+ String availableResourcePath = null;
+ while (it.hasNext()) {
+ availableResourcePath = it.next();
+ if (resourceResolver.getResource(availableResourcePath) != null) {
+ break;
+ }
+ }
+
+ selectors.clear();
+ extension = null;
+ suffix = null;
+ if (availableResourcePath.length() == path.length()) {
+ resourcePath = availableResourcePath;
+ } else {
+ setPathWithDefinedResourcePosition(path, availableResourcePath.length());
+ }
+ return this;
+ }
+
+ /**
+ * @param resourcePath
+ * @return the builder for method chaining
+ */
+ public ResourceUriBuilder setResourcePath(String resourcePath) {
+ if (schemeSpecificPart != null) {
+ return this;
+ }
+ this.resourcePath = resourcePath;
+ return this;
+ }
+
+ /**
+ * @param selectors
+ * @return the builder for method chaining
+ */
+ public ResourceUriBuilder setSelectors(String[] selectors) {
+ if (schemeSpecificPart != null || resourcePath == null) {
+ return this;
+ }
+ this.selectors.clear();
+ Arrays.stream(selectors).forEach(this.selectors::add);
+ return this;
+ }
+
+ /**
+ * @param selector
+ * @return the builder for method chaining
+ */
+ public ResourceUriBuilder addSelector(String selector) {
+ if (schemeSpecificPart != null || resourcePath == null) {
+ return this;
+ }
+ this.selectors.add(selector);
+ return this;
+ }
+
+ /**
+ * @param extension
+ * @return the builder for method chaining
+ */
+ public ResourceUriBuilder setExtension(String extension) {
+ if (schemeSpecificPart != null || resourcePath == null) {
+ return this;
+ }
+ this.extension = extension;
+ return this;
+ }
+
+ /**
+ * @return returns the path parameters
+ */
+ public ResourceUriBuilder setPathParameter(String key, String value) {
+ if (schemeSpecificPart != null || resourcePath == null) {
+ return this;
+ }
+ this.pathParameters.put(key, value);
+ return this;
+ }
+
+ public ResourceUriBuilder setPathParameters(Map<String, String> pathParameters) {
+ this.pathParameters.clear();
+ this.pathParameters.putAll(pathParameters);
+ return this;
+ }
+
+ /**
+ * @param suffix
+ * @return the builder for method chaining
+ */
+ public ResourceUriBuilder setSuffix(String suffix) {
+ if (schemeSpecificPart != null || resourcePath == null) {
+ return this;
+ }
+ if (suffix != null && !StringUtils.startsWith(suffix, "/")) {
+ throw new IllegalArgumentException("Suffix needs to start with slash");
+ }
+ this.suffix = suffix;
+ return this;
+ }
+
+ /** @param query
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setQuery(String query) {
+ if (schemeSpecificPart != null) {
+ return this;
+ }
+ this.query = query;
+ return this;
+ }
+
+ /** @param urlFragment
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setFragment(String urlFragment) {
+ if (schemeSpecificPart != null) {
+ return this;
+ }
+ this.fragment = urlFragment;
+ return this;
+ }
+
+ /** @param scheme
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setScheme(String scheme) {
+ this.scheme = scheme;
+ return this;
+ }
+
+ /** @param schemeSpecificPart
+ * @return the builder for method chaining */
+ public ResourceUriBuilder setSchemeSpecificPart(String schemeSpecificPart) {
+ if (schemeSpecificPart != null && schemeSpecificPart.isEmpty()) {
+ return this;
+ }
+ this.schemeSpecificPart = schemeSpecificPart;
+ return this;
+ }
+
+ /** Will remove scheme and authority (that is user info, host and port).
+ *
+ * @return the builder for method chaining */
+ public ResourceUriBuilder removeSchemeAndAuthority() {
+ setScheme(null);
+ setUserInfo(null);
+ setHost(null);
+ setPort(-1);
+ return this;
+ }
+
+ /** Will take over scheme and authority (user info, host and port) from provided resourceUri.
+ *
+ * @param resourceUri
+ * @return the builder for method chaining */
+ public ResourceUriBuilder useSchemeAndAuthority(ResourceUri resourceUri) {
+ setScheme(resourceUri.getScheme());
+ setUserInfo(resourceUri.getUserInfo());
+ setHost(resourceUri.getHost());
+ setPort(resourceUri.getPort());
+ return this;
+ }
+
+ /**
+ * Sets the resource resolver (required for {@link RequestPathInfo#getSuffixResource()}).
+ *
+ * @param resourceResolver
+ * the resource resolver
+ * @return the builder for method chaining
+ */
+ public ResourceUriBuilder setResourceResolver(ResourceResolver resourceResolver) {
+ this.resourceResolver = resourceResolver;
+ return this;
+ }
+
+ /** Will take over scheme and authority (user info, host and port) from provided uri.
+ *
+ * @param uri
+ * @return the builder for method chaining */
+ public ResourceUriBuilder useSchemeAndAuthority(URI uri) {
+ useSchemeAndAuthority(createFrom(uri, resourceResolver).build());
+ return this;
+ }
+
+ /** Builds the immutable ResourceUri from this builder.
+ *
+ * @return the builder for method chaining */
+ public ResourceUri build() {
+ return new ImmutableResourceUri();
+ }
+
+ private String toStringInternal() {
+ StringBuilder requestUri = new StringBuilder();
+
+ if (StringUtils.isNotBlank(scheme)) {
+ requestUri.append(scheme + CHAR_COLON);
+ }
+ if (isNotBlank(scheme) && isNotBlank(host)) {
+ requestUri.append(CHAR_SLASH + CHAR_SLASH);
+ if (StringUtils.isNotBlank(userInfo)) {
+ requestUri.append(userInfo + CHAR_AT);
+ }
+ requestUri.append(host);
+ if (port > 0
+ && !(scheme.equals(HTTP_SCHEME) && port == HTTP_DEFAULT_PORT)
+ && !(scheme.equals(HTTPS_SCHEME) && port == HTTPS_DEFAULT_PORT)) {
+ requestUri.append(CHAR_COLON + port);
+ }
+ }
+ if (resourcePath != null) {
+ requestUri.append(assemblePath(true));
+ }
+ if (schemeSpecificPart != null) {
+ requestUri.append(schemeSpecificPart);
+ }
+ if (query != null) {
+ requestUri.append(CHAR_QM + query);
+ }
+ if (fragment != null) {
+ requestUri.append(CHAR_HASH + fragment);
+ }
+ return requestUri.toString();
+ }
+
+ /** @return string representation of builder */
+ public String toString() {
+ return toStringInternal();
+ }
+
+ private void setPathWithDefinedResourcePosition(String path, int firstDotPositionAfterResourcePath) {
+ setResourcePath(path.substring(0, firstDotPositionAfterResourcePath));
+ int firstSlashAfterFirstDotPosition = path.indexOf(CHAR_SLASH, firstDotPositionAfterResourcePath);
+ String pathWithoutSuffix = firstSlashAfterFirstDotPosition > -1
+ ? path.substring(firstDotPositionAfterResourcePath + 1, firstSlashAfterFirstDotPosition)
+ : path.substring(firstDotPositionAfterResourcePath + 1);
+ String[] pathBits = pathWithoutSuffix.split(SELECTOR_DOT_REGEX);
+ if (pathBits.length > 1) {
+ setSelectors(Arrays.copyOfRange(pathBits, 0, pathBits.length - 1));
+ }
+ setExtension(pathBits.length > 0 && pathBits[pathBits.length - 1].length() > 0 ? pathBits[pathBits.length - 1] : null);
+ setSuffix(firstSlashAfterFirstDotPosition > -1 ? path.substring(firstSlashAfterFirstDotPosition) : null);
+ }
+
+ private String extractPathParameters(String path) {
+ Map<String, String> currentPathParameters = null;
+ if (path != null) {
+ Pattern pathParameterRegex = Pattern.compile(PATH_PARAMETERS_REGEX);
+
+ StringBuffer resultString = null;
+ Matcher regexMatcher = pathParameterRegex.matcher(path);
+ while (regexMatcher.find()) {
+ if (resultString == null) {
+ resultString = new StringBuffer();
+ }
+ if (currentPathParameters == null) {
+ currentPathParameters = new LinkedHashMap<>();
+ }
+ regexMatcher.appendReplacement(resultString, "");
+ String key = regexMatcher.group(1);
+ String value = StringUtils.defaultIfEmpty(regexMatcher.group(2), regexMatcher.group(3));
+ currentPathParameters.put(key, value);
+ }
+ if (resultString != null) {
+ regexMatcher.appendTail(resultString);
+ path = resultString.toString();
+ pathParameters.putAll(currentPathParameters);
+ }
+ }
+ return path;
+ }
+
+ private String assemblePath(boolean includePathParamters) {
+ if (resourcePath == null) {
+ return null;
+ }
+
+ StringBuilder pathBuilder = new StringBuilder();
+ pathBuilder.append(resourcePath);
+ if (includePathParamters && !pathParameters.isEmpty()) {
+ for (Map.Entry<String, String> pathParameter : pathParameters.entrySet()) {
+ pathBuilder.append(CHAR_SEMICOLON + pathParameter.getKey() + CHAR_EQUALS +
+ CHAR_SINGLEQUOTE + pathParameter.getValue() + CHAR_SINGLEQUOTE);
+ }
+ }
+
+ boolean dotAdded = false;
+ if (!selectors.isEmpty()) {
+ pathBuilder.append(CHAR_DOT + String.join(CHAR_DOT, selectors));
+ dotAdded = true;
+ }
+ if (!StringUtils.isBlank(extension)) {
+ pathBuilder.append(CHAR_DOT + extension);
+ dotAdded = true;
+ }
+
+ if (!StringUtils.isBlank(suffix)) {
+ if (!dotAdded) {
+ pathBuilder.append(CHAR_DOT);
+ }
+ pathBuilder.append(suffix);
+ }
+ return pathBuilder.toString();
+ }
+
+
+ // read-only view on the builder data (to avoid another copy of the data into a new object)
+ private class ImmutableResourceUri implements ResourceUri {
+
+ @Override
+ public String getResourcePath() {
+ return resourcePath;
+ }
+
+ // returns null in line with
+ // https://sling.apache.org/apidocs/sling11/org/apache/sling/api/request/RequestPathInfo.html#getSelectorString--
+ @Override
+ public String getSelectorString() {
+ return !selectors.isEmpty() ? String.join(CHAR_DOT, selectors) : null;
+ }
+
+ @Override
+ public String[] getSelectors() {
+ return selectors.toArray(new String[selectors.size()]);
+ }
+
+ @Override
+ public String getExtension() {
+ return extension;
+ }
+
+ @Override
+ public Map<String, String> getPathParameters() {
+ return Collections.unmodifiableMap(pathParameters);
+ }
+
+ @Override
+ public String getSuffix() {
+ return suffix;
+ }
+
+ @Override
+ public String getPath() {
+ return assemblePath(true);
+ }
+
+ @Override
+ public String getSchemeSpecificPart() {
+ return schemeSpecificPart;
+ }
+
+ @Override
+ public String getQuery() {
+ return query;
+ }
+
+ @Override
+ public String getFragment() {
+ return fragment;
+ }
+
+ @Override
+ public String getScheme() {
+ return scheme;
+ }
+
+ @Override
+ public String getHost() {
+ return host;
+ }
+
+ @Override
+ public int getPort() {
+ return port;
+ }
+
+ @Override
+ public Resource getSuffixResource() {
+ if (StringUtils.isNotBlank(suffix) && resourceResolver != null) {
+ return resourceResolver.resolve(suffix);
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ public String getUserInfo() {
+ return userInfo;
+ }
+
+ @Override
+ public String toString() {
+ return toStringInternal();
+ }
+
+ @Override
+ public URI toUri() {
+ String uriString = toString();
+ try {
+ return new URI(uriString);
+ } catch (URISyntaxException e) {
+ throw new IllegalArgumentException("Invalid Sling URI: " + uriString, e);
+ }
+ }
+
+ private ResourceUriBuilder getBuilder() {
+ return ResourceUriBuilder.this;
+ }
+
+ // generated hashCode() and equals()
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((extension == null) ? 0 : extension.hashCode());
+ result = prime * result + ((fragment == null) ? 0 : fragment.hashCode());
+ result = prime * result + ((host == null) ? 0 : host.hashCode());
+ result = prime * result + ((pathParameters == null) ? 0 : pathParameters.hashCode());
+ result = prime * result + port;
+ result = prime * result + ((query == null) ? 0 : query.hashCode());
+ result = prime * result + ((resourcePath == null) ? 0 : resourcePath.hashCode());
+ result = prime * result + ((scheme == null) ? 0 : scheme.hashCode());
+ result = prime * result + ((schemeSpecificPart == null) ? 0 : schemeSpecificPart.hashCode());
+ result = prime * result + ((selectors == null) ? 0 : selectors.hashCode());
+ result = prime * result + ((suffix == null) ? 0 : suffix.hashCode());
+ result = prime * result + ((userInfo == null) ? 0 : userInfo.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ ImmutableResourceUri other = (ImmutableResourceUri) obj;
+ if (extension == null) {
+ if (other.getBuilder().extension != null)
+ return false;
+ } else if (!extension.equals(other.getBuilder().extension))
+ return false;
+ if (fragment == null) {
+ if (other.getBuilder().fragment != null)
+ return false;
+ } else if (!fragment.equals(other.getBuilder().fragment))
+ return false;
+ if (host == null) {
+ if (other.getBuilder().host != null)
+ return false;
+ } else if (!host.equals(other.getBuilder().host))
+ return false;
+ if (pathParameters == null) {
+ if (other.getBuilder().pathParameters != null)
+ return false;
+ } else if (!pathParameters.equals(other.getBuilder().pathParameters))
+ return false;
+ if (port != other.getBuilder().port)
+ return false;
+ if (query == null) {
+ if (other.getBuilder().query != null)
+ return false;
+ } else if (!query.equals(other.getBuilder().query))
+ return false;
+ if (resourcePath == null) {
+ if (other.getBuilder().resourcePath != null)
+ return false;
+ } else if (!resourcePath.equals(other.getBuilder().resourcePath))
+ return false;
+ if (scheme == null) {
+ if (other.getBuilder().scheme != null)
+ return false;
+ } else if (!scheme.equals(other.getBuilder().scheme))
+ return false;
+ if (schemeSpecificPart == null) {
+ if (other.getBuilder().schemeSpecificPart != null)
+ return false;
+ } else if (!schemeSpecificPart.equals(other.getBuilder().schemeSpecificPart))
+ return false;
+ if (selectors == null) {
+ if (other.getBuilder().selectors != null)
+ return false;
+ } else if (!selectors.equals(other.getBuilder().selectors))
+ return false;
+ if (suffix == null) {
+ if (other.getBuilder().suffix != null)
+ return false;
+ } else if (!suffix.equals(other.getBuilder().suffix))
+ return false;
+ if (userInfo == null) {
+ if (other.getBuilder().userInfo != null)
+ return false;
+ } else if (!userInfo.equals(other.getBuilder().userInfo))
+ return false;
+ return true;
+ }
+
+ }
+
+ /** Iterate over a path by creating shorter segments of that path using "." as a separator.
+ * <p>
+ * For example, if path = /some/path.a4.html/xyz.ext the sequence is:
+ * <ol>
+ * <li>/some/path.a4.html/xyz.ext</li>
+ * <li>/some/path.a4.html/xyz</li>
+ * <li>/some/path.a4</li>
+ * <li>/some/path</li>
+ * </ol>
+ * <p>
+ * The root path (/) is never returned. */
+ private class ResourcePathIterator implements Iterator<String> {
+
+ // the next path to return, null if nothing more to return
+ private String nextPath;
+
+ /** Creates a new instance iterating over the given path
+ *
+ * @param path The path to iterate over. If this is empty or <code>null</code> this iterator will not return anything. */
+ private ResourcePathIterator(String path) {
+ if (path == null || path.length() == 0) {
+ // null or empty path, there is nothing to return
+ nextPath = null;
+ } else {
+ // find last non-slash character
+ int i = path.length() - 1;
+ while (i >= 0 && path.charAt(i) == '/') {
+ i--;
+ }
+ if (i < 0) {
+ // only slashes, assume root node
+ nextPath = "/";
+ } else if (i < path.length() - 1) {
+ // cut off slash
+ nextPath = path.substring(0, i + 1);
+ } else {
+ // no trailing slash
+ nextPath = path;
+ }
+ }
+ }
+
+ public boolean hasNext() {
+ return nextPath != null;
+ }
+
+ public String next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
+ final String result = nextPath;
+ // find next path
+ int lastDot = nextPath.lastIndexOf('.');
+ nextPath = (lastDot > 0) ? nextPath.substring(0, lastDot) : null;
+
+ return result;
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException("remove");
+ }
+ }
+
+}
diff --git a/src/main/java/org/apache/sling/api/resource/uri/package-info.java b/src/main/java/org/apache/sling/api/resource/uri/package-info.java
new file mode 100644
index 0000000..dd21e49
--- /dev/null
+++ b/src/main/java/org/apache/sling/api/resource/uri/package-info.java
@@ -0,0 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+@Version("1.0.0")
+package org.apache.sling.api.resource.uri;
+
+import org.osgi.annotation.versioning.Version;
+
diff --git a/src/test/java/org/apache/sling/api/resource/uri/ResourceUriBuilderTest.java b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriBuilderTest.java
new file mode 100644
index 0000000..523b594
--- /dev/null
+++ b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriBuilderTest.java
@@ -0,0 +1,157 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.api.resource.uri;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.when;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import org.apache.sling.api.SlingHttpServletRequest;
+import org.apache.sling.api.request.RequestPathInfo;
+import org.apache.sling.api.resource.Resource;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ResourceUriBuilderTest {
+
+ @Mock
+ SlingHttpServletRequest request;
+
+ @Mock
+ RequestPathInfo requestPathInfo;
+
+ @Mock
+ Resource resource;
+
+ @Before
+ public void before() {
+ when(request.getRequestPathInfo()).thenReturn(requestPathInfo);
+ }
+
+ @Test
+ public void testBasicUsage() {
+
+ ResourceUri testUri = ResourceUriBuilder.create()
+ .setResourcePath("/test/to/path")
+ .setSelectors(new String[] { "sel1", "sel2" })
+ .setExtension("html")
+ .setSuffix("/suffix/path")
+ .setQuery("par1=val1&par2=val2")
+ .build();
+
+ assertEquals("/test/to/path.sel1.sel2.html/suffix/path?par1=val1&par2=val2", testUri.toString());
+ }
+
+ // the tests in ResourceUriTest extensively test the builder's parse method by using it for constructing
+ // all types of ResourceUris
+ @Test
+ public void testParse() {
+
+ String testUriStr = "https://example.com/test/to/path.sel1.sel2.html";
+ ResourceUri testUri = ResourceUriBuilder.parse(testUriStr, null).build();
+ assertEquals(testUriStr, testUri.toString());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testParseInvalidUri() {
+ ResourceUriBuilder.parse(":foo", null);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSetInvalidSuffix() {
+ ResourceUriBuilder.parse("/test/to/path.sel1.html", null).setSuffix("suffixWithoutSlash");
+ }
+
+ @Test
+ public void testCreateFromRequest() {
+
+ when(request.getScheme()).thenReturn("https");
+ when(request.getServerName()).thenReturn("example.com");
+ when(request.getServerPort()).thenReturn(443);
+ when(request.getQueryString()).thenReturn("par1=val1");
+ when(requestPathInfo.getResourcePath()).thenReturn("/test/to/path");
+ when(requestPathInfo.getSelectors()).thenReturn(new String[] { "sel1", "sel2" });
+ when(requestPathInfo.getExtension()).thenReturn("html");
+ when(requestPathInfo.getSuffix()).thenReturn("/suffix/path");
+
+ ResourceUri testUri = ResourceUriBuilder.createFrom(request).build();
+
+ assertEquals("https://example.com/test/to/path.sel1.sel2.html/suffix/path?par1=val1", testUri.toString());
+ }
+
+ @Test
+ public void testCreateFromResource() {
+
+ when(resource.getPath()).thenReturn("/test/to/path");
+ ResourceUri testUri = ResourceUriBuilder.createFrom(resource).build();
+
+ assertEquals("/test/to/path", testUri.getResourcePath());
+ assertNull(testUri.getSelectorString());
+ assertNull(testUri.getExtension());
+ assertNull(testUri.getSuffix());
+ }
+
+ @Test
+ public void testCreateFromResourceWithDotInPath() {
+
+ when(resource.getPath()).thenReturn("/test/to/image.jpg");
+ ResourceUri testUri = ResourceUriBuilder.createFrom(resource).build();
+
+ assertEquals("/test/to/image.jpg", testUri.getResourcePath());
+ assertNull(testUri.getSelectorString());
+ assertNull(testUri.getExtension());
+ assertNull(testUri.getSuffix());
+ }
+
+ @Test
+ public void testCreateFromPath() {
+
+ when(request.getScheme()).thenReturn("https");
+ when(request.getServerName()).thenReturn("example.com");
+ when(request.getServerPort()).thenReturn(443);
+ when(request.getQueryString()).thenReturn("par1=val1");
+ when(requestPathInfo.getResourcePath()).thenReturn("/test/to/path");
+ when(requestPathInfo.getSelectors()).thenReturn(new String[] { "sel1", "sel2" });
+ when(requestPathInfo.getExtension()).thenReturn("html");
+ when(requestPathInfo.getSuffix()).thenReturn("/suffix/path");
+
+ ResourceUri testUri = ResourceUriBuilder.createFrom(request).build();
+
+ assertEquals("https://example.com/test/to/path.sel1.sel2.html/suffix/path?par1=val1", testUri.toString());
+ }
+
+ @Test
+ public void testUseSchemeAndAuthority() throws URISyntaxException {
+
+ URI testUriToUseSchemeAndAuthorityFrom = new URI("https://example.com:8080/test/to/path.sel1.sel2.html");
+ String testPath = "/path/to/page.html";
+ ResourceUri testUri = ResourceUriBuilder.parse(testPath, null)
+ .useSchemeAndAuthority(testUriToUseSchemeAndAuthorityFrom)
+ .build();
+ assertEquals("https://example.com:8080/path/to/page.html", testUri.toString());
+ }
+
+}
diff --git a/src/test/java/org/apache/sling/api/resource/uri/ResourceUriBuilderWithAdjustMethodTest.java b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriBuilderWithAdjustMethodTest.java
new file mode 100644
index 0000000..87c233d
--- /dev/null
+++ b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriBuilderWithAdjustMethodTest.java
@@ -0,0 +1,244 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.api.resource.uri;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import java.util.function.Consumer;
+
+import org.apache.sling.api.resource.ResourceResolver;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ResourceUriBuilderWithAdjustMethodTest {
+
+ @Test
+ public void testAdjustAddSelectorFullUrl() {
+
+ testAdjustUri(
+ "http://host.com/test/to/path.html",
+ resourceUriBuilder -> {
+ resourceUriBuilder.addSelector("test");
+ },
+ "http://host.com/test/to/path.test.html",
+ resourceUri -> {
+ assertEquals("test", resourceUri.getSelectorString());
+ });
+ }
+
+ @Test
+ public void testAdjustAddSelectorAndSuffixPath() {
+
+ testAdjustUri(
+ "/test/to/path.html",
+ resourceUriBuilder -> {
+ resourceUriBuilder.addSelector("test");
+ resourceUriBuilder.setSuffix("/suffix/path/to/file");
+ },
+ "/test/to/path.test.html/suffix/path/to/file",
+ resourceUri -> {
+ assertArrayEquals(new String[] { "test" }, resourceUri.getSelectors());
+ assertEquals("/suffix/path/to/file", resourceUri.getSuffix());
+ });
+ }
+
+ @Test
+ public void testExtendSimplePathToFullUrl() {
+
+ testAdjustUri(
+ "/test/to/path.html",
+ resourceUriBuilder -> {
+ resourceUriBuilder.setScheme("https");
+ resourceUriBuilder.setHost("example.com");
+ resourceUriBuilder.setSuffix("/suffix/path/to/file");
+ },
+ "https://example.com/test/to/path.html/suffix/path/to/file",
+ resourceUri -> {
+ assertEquals("https", resourceUri.getScheme());
+ assertEquals("example.com", resourceUri.getHost());
+ assertEquals("/suffix/path/to/file", resourceUri.getSuffix());
+ });
+ }
+
+ @Test
+ public void testSetSelectorAndSuffixToRelativeUrl() {
+
+ testAdjustUri(
+ "../to/path.html",
+ resourceUriBuilder -> {
+ resourceUriBuilder.addSelector("sel1");
+ resourceUriBuilder.setSuffix("/suffix/path/to/file");
+ },
+ "../to/path.sel1.html/suffix/path/to/file",
+ resourceUri -> {
+ assertEquals("../to/path", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("/suffix/path/to/file", resourceUri.getSuffix());
+ });
+ }
+
+ @Test
+ public void testFullUrltoSimplePath() {
+
+ testAdjustUri(
+ "https://user:pw@example.com/test/to/path.html/suffix/path/to/file",
+ resourceUriBuilder -> {
+ resourceUriBuilder.removeSchemeAndAuthority();
+ },
+ "/test/to/path.html/suffix/path/to/file",
+ resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ });
+ }
+
+ @Test
+ public void testAdjustPathInOpaqueUriWithoutEffect() {
+
+ testAdjustUri(
+ "mailto:jon.doe@example.com",
+ resourceUriBuilder -> {
+ resourceUriBuilder.setUserInfo("user:pw");
+ resourceUriBuilder.setHost("example.com");
+ resourceUriBuilder.setPort(500);
+ resourceUriBuilder.setPath("/path/to/resource");
+ resourceUriBuilder.setResourcePath("/path/to/resource");
+ resourceUriBuilder.addSelector("test");
+ resourceUriBuilder.setExtension("html");
+ resourceUriBuilder.setSuffix("/suffix");
+ },
+ "mailto:jon.doe@example.com",
+ resourceUri -> {
+ assertNull(resourceUri.getHost());
+ assertNull(resourceUri.getResourcePath());
+ assertNull(resourceUri.getSelectorString());
+ assertNull(resourceUri.getExtension());
+ assertNull(resourceUri.getSuffix());
+ });
+ }
+
+ @Test
+ public void testAdjustOpaqueToNormalUrl() {
+
+ testAdjustUri(
+ "mailto:jon.doe@example.com",
+ resourceUriBuilder -> {
+ resourceUriBuilder.setSchemeSpecificPart(null);
+ resourceUriBuilder.setScheme("https");
+ resourceUriBuilder.setHost("example.com");
+ resourceUriBuilder.setPath("/path/to/resource.html");
+ },
+ "https://example.com/path/to/resource.html",
+ resourceUri -> {
+ assertNull(resourceUri.getSchemeSpecificPart());
+ });
+ }
+
+ @Test
+ public void testAdjustOpaqueUri() {
+
+ testAdjustUri(
+ "mailto:jon.doe@example.com",
+ resourceUriBuilder -> {
+ resourceUriBuilder.setSchemeSpecificPart("mary.doe@example.com");
+ },
+ "mailto:mary.doe@example.com",
+ resourceUri -> {
+ assertEquals("mary.doe@example.com", resourceUri.getSchemeSpecificPart());
+ assertNull(resourceUri.getResourcePath());
+ });
+ }
+
+ @Test
+ public void testAdjustSelectorsInFragmentOnlyUrlWithoutEffect() {
+
+ testAdjustUri(
+ "#fragment",
+ resourceUriBuilder -> {
+ resourceUriBuilder.addSelector("test");
+ resourceUriBuilder.setSuffix("/suffix");
+ },
+ "#fragment",
+ resourceUri -> {
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getSuffix());
+ });
+ }
+
+ @Test
+ public void testAjustFtpUrl() {
+
+ testAdjustUri(
+ "sftp://user:pw@example.com:9090/some/path",
+ resourceUriBuilder -> {
+ resourceUriBuilder.setPath("/some/other/path");
+ resourceUriBuilder.setPort(9091);
+ },
+ "sftp://user:pw@example.com:9091/some/other/path",
+ resourceUri -> {
+ assertEquals("/some/other/path", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(9091, resourceUri.getPort());
+ });
+ }
+
+ @Test
+ public void testAdjustPathParameter() {
+
+ testAdjustUri(
+ "/test/to/path.sel1.html/suffix/path/to/file",
+ resourceUriBuilder -> {
+ resourceUriBuilder.setPathParameter("v", "2.0");
+ },
+ "/test/to/path;v='2.0'.sel1.html/suffix/path/to/file",
+ resourceUri -> {
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+ assertEquals("/suffix/path/to/file", resourceUri.getSuffix());
+ assertEquals(1, resourceUri.getPathParameters().size());
+ assertEquals("2.0", resourceUri.getPathParameters().get("v"));
+ });
+ }
+
+ // -- helper methods
+
+ public static void testAdjustUri(String testUri, Consumer<ResourceUriBuilder> adjuster, String testUriAfterEdit,
+ Consumer<ResourceUri> additionalAssertions) {
+ testAdjustUri(testUri, adjuster, testUriAfterEdit, additionalAssertions, null);
+ }
+
+ public static void testAdjustUri(String testUri, Consumer<ResourceUriBuilder> adjuster, String testUriAfterEdit,
+ Consumer<ResourceUri> additionalAssertions, ResourceResolver resourceResolver) {
+ ResourceUri resourceUri = ResourceUriBuilder.parse(testUri, resourceResolver).build();
+
+ ResourceUri adjustedResourceUri = resourceUri.adjust(adjuster);
+
+ assertEquals(testUriAfterEdit, adjustedResourceUri.toString());
+ assertEquals(testUriAfterEdit, adjustedResourceUri.toUri().toString());
+
+ additionalAssertions.accept(adjustedResourceUri);
+ }
+
+}
diff --git a/src/test/java/org/apache/sling/api/resource/uri/ResourceUriRebaseTest.java b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriRebaseTest.java
new file mode 100644
index 0000000..ea2e986
--- /dev/null
+++ b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriRebaseTest.java
@@ -0,0 +1,231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.api.resource.uri;
+
+import static org.apache.sling.api.resource.uri.ResourceUriTest.testUri;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import java.net.URISyntaxException;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.Silent.class)
+public class ResourceUriRebaseTest {
+
+ private static final String FULL_URI = "/test/to/file.ext.sel1.json/suffix/path.js";
+
+ @Mock
+ ResourceResolver resolver;
+
+ @Mock
+ Resource resource;
+
+ @Test
+ public void testRebaseResourcePathSimplePath() {
+ String testUriStrSimple = "/test/to/file";
+ when(resolver.getResource("/test/to/file")).thenReturn(resource);
+ testUri(testUriStrSimple, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test
+ public void testRebaseResourcePathSimpleResourcePathIncludesExtension() {
+
+ String testUriStrSimpleFile = "/test/to/file.css";
+ when(resolver.getResource("/test/to/file.css")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file")).thenReturn(null);
+ testUri(testUriStrSimpleFile, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file.css", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test
+ public void testRebaseResourcePathSimpleResourcePathExcludesExtension() {
+ String testUriStrSimplePage = "/path/to/page.html";
+ when(resolver.getResource("/path/to/page.html")).thenReturn(null);
+ when(resolver.getResource("/path/to/page")).thenReturn(resource);
+ testUri(testUriStrSimplePage, true, true, false, false, false, resourceUri -> {
+ assertEquals("/path/to/page", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test
+ public void testRebaseResourcePathFullPathIsResource() {
+
+ // pull path with suffix is resource path
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(null);
+ when(resolver.getResource("/test/to/file")).thenReturn(null);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file.ext.sel1.json/suffix/path.js", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test
+ public void testRebaseResourcePathPartOfSuffixIsResource() {
+ //
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(null);
+ when(resolver.getResource("/test/to/file")).thenReturn(null);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file.ext.sel1.json/suffix/path", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals("js", resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test
+ public void testRebaseResourcePathWithSelectorsAndExtension() {
+ // if the resource for before the suffix part exits, it is ignored
+ // compare org.apache.sling.resourceresolver.impl.helper.ResourcePathIteratorTest.testMixed()
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(null);
+ when(resolver.getResource("/test/to/file")).thenReturn(null);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file", resourceUri.getResourcePath());
+ assertEquals("ext.sel1", resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path.js", resourceUri.getSuffix());
+ }, resolver);
+
+ }
+
+ @Test
+ public void testRebaseResourcePathContainsTwoDots() {
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(null);
+ when(resolver.getResource("/test/to/file")).thenReturn(null);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file.ext.sel1", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path.js", resourceUri.getSuffix());
+ }, resolver);
+
+ }
+
+ @Test
+ public void testRebaseResourcePathContainsExtension() {
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file")).thenReturn(null);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file.ext", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path.js", resourceUri.getSuffix());
+ }, resolver);
+
+ }
+
+ @Test
+ public void testRebaseResourcePathWithoutDot() {
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(null);
+ when(resolver.getResource("/test/to/file")).thenReturn(resource);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file", resourceUri.getResourcePath());
+ assertEquals("ext.sel1", resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path.js", resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test
+ public void testRebaseResourcePathLongestMatchingPathWins() {
+ // side by side resources in same folder: the longest path wins
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(resource);
+ when(resolver.getResource("/test/to/file")).thenReturn(resource);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file.ext.sel1", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path.js", resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test
+ public void testRebaseResourcePathNoResourceExistsAtAll() {
+ // if no resource exists at all the first dot has to be taken as split
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path.js")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json/suffix/path")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1.json")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext.sel1")).thenReturn(null);
+ when(resolver.getResource("/test/to/file.ext")).thenReturn(null);
+ when(resolver.getResource("/test/to/file")).thenReturn(null);
+ testUri(FULL_URI, true, true, false, false, false, resourceUri -> {
+ assertEquals("/test/to/file", resourceUri.getResourcePath());
+ assertEquals("ext.sel1", resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path.js", resourceUri.getSuffix());
+ }, resolver);
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void testRebaseNotAllowedWithoutResolver() throws URISyntaxException {
+
+ String testPath = "/path/to/page.html";
+ ResourceUriBuilder.parse(testPath, null)
+ .rebaseResourcePath()
+ .build();
+ }
+
+}
diff --git a/src/test/java/org/apache/sling/api/resource/uri/ResourceUriTest.java b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriTest.java
new file mode 100644
index 0000000..18cd6e3
--- /dev/null
+++ b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriTest.java
@@ -0,0 +1,442 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.sling.api.resource.uri;
+
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+import org.apache.sling.api.resource.ResourceResolver;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ResourceUriTest {
+
+ @Mock
+ ResourceResolver resolver;
+
+ @Test
+ public void testFullResourceUri() {
+
+ String testUriStr = "http://host.com/test/to/path.html";
+ testUri(testUriStr, false, false, false, true, false, resourceUri -> {
+ assertEquals("http", resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals("host.com", resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+
+ }
+
+ @Test
+ public void testFullResourceUriComplex() {
+
+ String testUriStr = "https://test:pw@host.com:888/test/to/path.sel1.json/suffix/path?p1=2&p2=3#frag3939";
+ testUri(testUriStr, false, false, false, true, false, resourceUri -> {
+ assertEquals("https", resourceUri.getScheme());
+ assertEquals("test:pw", resourceUri.getUserInfo());
+ assertEquals("host.com", resourceUri.getHost());
+ assertEquals(888, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("p1=2&p2=3", resourceUri.getQuery());
+ assertEquals("frag3939", resourceUri.getFragment());
+ }, asList(resolver, null));
+
+ }
+
+ @Test
+ public void testAbsolutePathResourceUri() {
+ String testUriStr = "/test/to/path.sel1.json/suffix/path?p1=2&p2=3#frag3939";
+
+ testUri(testUriStr, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals("/suffix/path", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("p1=2&p2=3", resourceUri.getQuery());
+ assertEquals("frag3939", resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testResourceUriSuffixWithDots() {
+
+ String testUriStr = "/test/to/path.min.js/suffix/app.nodesbrowser.js";
+ testUri(testUriStr, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals("min", resourceUri.getSelectorString());
+ assertEquals("js", resourceUri.getExtension());
+ assertEquals("/suffix/app.nodesbrowser.js", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testResourceUriMultipleDots() {
+
+ String testUriStr = "/test/to/path.sel1.sel2..sel4.js";
+ testUri(testUriStr, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals(4, resourceUri.getSelectors().length);
+ assertEquals("sel1.sel2..sel4", resourceUri.getSelectorString());
+ assertEquals("js", resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+
+ String testUriStr2 = "/test/to/path.sel1.sel2../sel4.js";
+ testUri(testUriStr2, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals(1, resourceUri.getSelectors().length);
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("sel2", resourceUri.getExtension());
+ assertEquals("/sel4.js", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, null, true);
+ }
+
+ @Test
+ public void testRelativePathResourceUri() {
+ String testUriStr = "../path.html#frag1";
+
+ testUri(testUriStr, true, false, true, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("../path", resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals("frag1", resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testRelativePathResourceUriComplex() {
+ String testUriStr = "../path/./deep/path/../path.sel1.sel2.html?test=1#frag1";
+
+ testUri(testUriStr, true, false, true, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("../path/./deep/path/../path", resourceUri.getResourcePath());
+ assertEquals("sel1.sel2", resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("test=1", resourceUri.getQuery());
+ assertEquals("frag1", resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testAbsolutePathWithPathParameter() {
+ String testUriStr = "/test/to/path;v='1.0'.sel1.html/suffix/path?p1=2&p2=3#frag3939";
+
+ testUri(testUriStr, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+ assertEquals(1, resourceUri.getPathParameters().size());
+ assertEquals("1.0", resourceUri.getPathParameters().get("v"));
+ assertEquals("/suffix/path", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("p1=2&p2=3", resourceUri.getQuery());
+ assertEquals("frag3939", resourceUri.getFragment());
+ }, asList(resolver, null));
+
+ String testUriStr2 = "/test/to/file;foo='bar'.sel1.sel2.json/suffix/path";
+ testUri(testUriStr2, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/file", resourceUri.getResourcePath());
+ assertEquals("sel1.sel2", resourceUri.getSelectorString());
+ assertEquals("json", resourceUri.getExtension());
+ assertEquals(1, resourceUri.getPathParameters().size());
+ assertEquals("bar", resourceUri.getPathParameters().get("foo"));
+ assertEquals("/suffix/path", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testAbsolutePathWithPathParameterMultiple() {
+ String testUriStr = "/test/to/path;v='1.0';antotherParam='test/nested';antotherParam2='7'.sel1.html/suffix/path?p1=2&p2=3#frag3939";
+
+ testUri(testUriStr, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+
+ assertEquals(3, resourceUri.getPathParameters().size());
+ assertEquals("1.0", resourceUri.getPathParameters().get("v"));
+ assertEquals("test/nested", resourceUri.getPathParameters().get("antotherParam"));
+ assertEquals("7", resourceUri.getPathParameters().get("antotherParam2"));
+
+ assertEquals("/suffix/path", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("p1=2&p2=3", resourceUri.getQuery());
+ assertEquals("frag3939", resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testAbsolutePathWithPathParameterAfterExtension() {
+ String testUriStr = "/test/to/path.sel1.html;v='1.0'/suffix/path?p1=2&p2=3#frag3939";
+
+ ResourceUri testUri = testUri(testUriStr, true, true, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals("/test/to/path", resourceUri.getResourcePath());
+ assertEquals("sel1", resourceUri.getSelectorString());
+ assertEquals("html", resourceUri.getExtension());
+ assertEquals(1, resourceUri.getPathParameters().size());
+ assertEquals("1.0", resourceUri.getPathParameters().get("v"));
+ assertEquals("/suffix/path", resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("p1=2&p2=3", resourceUri.getQuery());
+ assertEquals("frag3939", resourceUri.getFragment());
+ }, null, true /* URL is restructured (parameter moved to end), assertion below */);
+
+ assertEquals("/test/to/path;v='1.0'.sel1.html/suffix/path?p1=2&p2=3#frag3939", testUri.toString());
+
+ }
+
+ @Test
+ public void testJavascriptUri() {
+ String testUriStr = "javascript:void(0)";
+
+ testUri(testUriStr, false, false, false, false, true, resourceUri -> {
+ assertEquals("javascript", resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals("void(0)", resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testMailtotUri() {
+ String testUriStr = "mailto:jon.doe@example.com";
+
+ testUri(testUriStr, false, false, false, false, true, resourceUri -> {
+ assertEquals("mailto", resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals("jon.doe@example.com", resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testHashOnlyUri() {
+
+ testUri("#", false, false, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals(null, resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals("", resourceUri.getFragment());
+ }, asList(resolver, null));
+
+ testUri("#fragment", false, false, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals(null, resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals("fragment", resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testQueryOnlyUri() {
+
+ testUri("?", false, false, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals(null, resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("", resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+
+ testUri("?test=test", false, false, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getScheme());
+ assertEquals(null, resourceUri.getUserInfo());
+ assertEquals(null, resourceUri.getHost());
+ assertEquals(-1, resourceUri.getPort());
+ assertEquals(null, resourceUri.getResourcePath());
+ assertEquals(null, resourceUri.getSelectorString());
+ assertEquals(null, resourceUri.getExtension());
+ assertEquals(null, resourceUri.getSuffix());
+ assertEquals(null, resourceUri.getSchemeSpecificPart());
+ assertEquals("test=test", resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ @Test
+ public void testUnusualQueryFragmentCombinations() {
+ testUri("?#", false, false, false, false, false, resourceUri -> {
+ assertEquals("", resourceUri.getQuery());
+ assertEquals("", resourceUri.getFragment());
+ }, asList(resolver, null));
+ testUri("?t=2#", false, false, false, false, false, resourceUri -> {
+ assertEquals("t=2", resourceUri.getQuery());
+ assertEquals("", resourceUri.getFragment());
+ }, asList(resolver, null));
+ testUri("?#t=3", false, false, false, false, false, resourceUri -> {
+ assertEquals("", resourceUri.getQuery());
+ assertEquals("t=3", resourceUri.getFragment());
+ }, asList(resolver, null));
+ testUri("", false, false, false, false, false, resourceUri -> {
+ assertEquals(null, resourceUri.getQuery());
+ assertEquals(null, resourceUri.getFragment());
+ }, asList(resolver, null));
+ }
+
+ // -- helper methods
+ public static void testUri(String testUri, boolean isPath, boolean isAbsolutePath, boolean isRelativePath, boolean isFullUri,
+ boolean isOpaque, Consumer<ResourceUri> additionalAssertions, List<ResourceResolver> resourceResolvers) {
+ for (ResourceResolver rr : resourceResolvers) {
+ testUri(testUri, isPath, isAbsolutePath, isRelativePath, isFullUri, isOpaque, additionalAssertions, rr);
+ }
+ }
+
+ public static ResourceUri testUri(String testUri, boolean isPath, boolean isAbsolutePath, boolean isRelativePath, boolean isFullUri,
+ boolean isOpaque, Consumer<ResourceUri> additionalAssertions) {
+ return testUri(testUri, isPath, isAbsolutePath, isRelativePath, isFullUri, isOpaque, additionalAssertions, (ResourceResolver) null);
+ }
+
+ public static ResourceUri testUri(String testUri, boolean isPath, boolean isAbsolutePath, boolean isRelativePath, boolean isFullUri,
+ boolean isOpaque, Consumer<ResourceUri> additionalAssertions, ResourceResolver resourceResolver) {
+ return testUri(testUri, isPath, isAbsolutePath, isRelativePath, isFullUri, isOpaque, additionalAssertions, resourceResolver, false);
+ }
+
+ public static ResourceUri testUri(String testUri, boolean isPath, boolean isAbsolutePath, boolean isRelativePath, boolean isFullUri,
+ boolean isOpaque, Consumer<ResourceUri> additionalAssertions, ResourceResolver resourceResolver, boolean urlIsRestructured) {
+ ResourceUri resourceUri = ResourceUriBuilder.parse(testUri, resourceResolver).build();
+
+ if (!urlIsRestructured) {
+ assertEquals("Uri toString() same as input", testUri, resourceUri.toString());
+ assertEquals("Uri toUri().toString() same as input", testUri, resourceUri.toUri().toString());
+ }
+
+ assertEquals("isPath()", isPath, resourceUri.isPath());
+ assertEquals("isAbsolutePath()", isAbsolutePath, resourceUri.isAbsolutePath());
+ assertEquals("isRelativePath()", isRelativePath, resourceUri.isRelativePath());
+ assertEquals("isFullUri()", isFullUri, resourceUri.isFullUri());
+ assertEquals("isOpaque()", isOpaque, resourceUri.isOpaque());
+ assertEquals("isOpaque() matches to java URI impl", resourceUri.toUri().isOpaque(), resourceUri.isOpaque());
+
+ additionalAssertions.accept(resourceUri);
+
+ ResourceUri resourceUriParsedFromSameInput = ResourceUriBuilder.parse(testUri, resourceResolver).build();
+ assertEquals("uris parsed from same input are expected to be equal", resourceUriParsedFromSameInput, resourceUri);
+ assertEquals("uris parsed from same input are expected to have the same hash code", resourceUriParsedFromSameInput.hashCode(),
+ resourceUri.hashCode());
+
+ return resourceUri;
+ }
+
+}
diff --git a/src/test/java/org/apache/sling/api/resource/uri/ResourceUriToSlingRequestPathInfoCompatibilityTest.java b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriToSlingRequestPathInfoCompatibilityTest.java
new file mode 100644
index 0000000..00ba823
--- /dev/null
+++ b/src/test/java/org/apache/sling/api/resource/uri/ResourceUriToSlingRequestPathInfoCompatibilityTest.java
@@ -0,0 +1,272 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sling.api.resource.uri;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.when;
+
+import org.apache.sling.api.request.RequestPathInfo;
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+// Replicates the same test cases as there are in SlingRequestPathInfoTest (from sling engine)
+// to ensure compatibility
+@RunWith(MockitoJUnitRunner.class)
+public class ResourceUriToSlingRequestPathInfoCompatibilityTest {
+
+ @Mock
+ ResourceResolver resourceResolver;
+
+ @Mock
+ Resource resource;
+
+ private RequestPathInfo createResourceUri(String resolutionPath, String resolutionPathInfo) {
+ when(resourceResolver.getResource(resolutionPath)).thenReturn(resource);
+ return ResourceUriBuilder.parse(resolutionPath + (resolutionPathInfo != null ? resolutionPathInfo : ""), resourceResolver).build();
+ }
+
+ @Test
+ public void testTrailingDot() {
+ RequestPathInfo p = createResourceUri("/some/path", ".");
+ assertEquals("/some/path", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testTrailingDotWithSuffix() {
+ RequestPathInfo p = createResourceUri("/some/path", "./suffix");
+ assertEquals("/some/path", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertEquals("/suffix", p.getSuffix());
+ }
+
+ @Test
+ public void testTrailingDotDot() {
+ RequestPathInfo p = createResourceUri("/some/path", "..");
+ assertEquals("/some/path", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testTrailingDotDotWithSuffix() {
+ RequestPathInfo p = createResourceUri("/some/path", "../suffix");
+ assertEquals("/some/path", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertEquals("/suffix", p.getSuffix());
+ }
+
+ @Test
+ public void testTrailingDotDotDot() {
+ RequestPathInfo p = createResourceUri("/some/path", "...");
+ assertEquals("/some/path", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testTrailingDotDotDotWithSuffix() {
+ RequestPathInfo p = createResourceUri("/some/path", ".../suffix");
+ assertEquals("/some/path", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertEquals("/suffix", p.getSuffix());
+ // the path changes slightly, the '.' is needed to still mark the suffix as suffix
+ assertEquals("/some/path./suffix", p.toString());
+ }
+
+ @Test
+ public void testAllOptions() {
+ RequestPathInfo p = createResourceUri("/some/path", ".print.a4.html/some/suffix");
+ assertEquals("/some/path", p.getResourcePath());
+ assertEquals("print.a4", p.getSelectorString());
+ assertEquals(2, p.getSelectors().length);
+ assertEquals("print", p.getSelectors()[0]);
+ assertEquals("a4", p.getSelectors()[1]);
+ assertEquals("html", p.getExtension());
+ assertEquals("/some/suffix", p.getSuffix());
+ }
+
+ @Test
+ public void testAllEmpty() {
+ RequestPathInfo p = createResourceUri("/", null);
+ assertEquals("/", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testPathOnly() {
+ RequestPathInfo p = createResourceUri("/some/path/here", "");
+ assertEquals("/some/path/here", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testPathWithExtensionOnly() {
+ RequestPathInfo p = createResourceUri("/some/path/here.html", "");
+ assertEquals("/some/path/here.html", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertNull("Extension is null", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testPathAndExtensionOnly() {
+ RequestPathInfo p = createResourceUri("/some/path/here", ".html");
+ assertEquals("/some/path/here", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertEquals("html", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testPathAndOneSelectorOnly() {
+ RequestPathInfo p = createResourceUri("/some/path/here", ".print.html");
+ assertEquals("/some/path/here", p.getResourcePath());
+ assertEquals("print", p.getSelectorString());
+ assertEquals(1, p.getSelectors().length);
+ assertEquals("print", p.getSelectors()[0]);
+ assertEquals("html", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ }
+
+ @Test
+ public void testPathExtAndSuffix() {
+ RequestPathInfo p = createResourceUri("/some/path/here", ".html/something");
+ assertEquals("/some/path/here", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertEquals("html", p.getExtension());
+ assertEquals("/something", p.getSuffix());
+ }
+
+ @Test
+ public void testSelectorsSplit() {
+ RequestPathInfo p = createResourceUri("/some/path", ".print.a4.html/some/suffix");
+ assertEquals("/some/path", p.getResourcePath());
+ assertEquals(2, p.getSelectors().length);
+ assertEquals("print", p.getSelectors()[0]);
+ assertEquals("a4", p.getSelectors()[1]);
+ assertEquals("html", p.getExtension());
+ assertEquals("/some/suffix", p.getSuffix());
+ }
+
+ @Test
+ public void testPartialResolutionB() {
+ RequestPathInfo p = createResourceUri("/some/path", ".print.a4.html/some/suffix");
+ assertEquals("/some/path", p.getResourcePath());
+ assertEquals("print.a4", p.getSelectorString());
+ assertEquals(2, p.getSelectors().length);
+ assertEquals("print", p.getSelectors()[0]);
+ assertEquals("a4", p.getSelectors()[1]);
+ assertEquals("html", p.getExtension());
+ assertEquals("/some/suffix", p.getSuffix());
+ }
+
+ @Test
+ public void testPartialResolutionC() {
+ RequestPathInfo p = createResourceUri("/some/path.print", ".a4.html/some/suffix");
+ assertEquals("/some/path.print", p.getResourcePath());
+ assertEquals("a4", p.getSelectorString());
+ assertEquals(1, p.getSelectors().length);
+ assertEquals("a4", p.getSelectors()[0]);
+ assertEquals("html", p.getExtension());
+ assertEquals("/some/suffix", p.getSuffix());
+ }
+
+ @Test
+ public void testPartialResolutionD() {
+ RequestPathInfo p = createResourceUri("/some/path.print.a4", ".html/some/suffix");
+ assertEquals("/some/path.print.a4", p.getResourcePath());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals(0, p.getSelectors().length);
+ assertEquals("html", p.getExtension());
+ assertEquals("/some/suffix", p.getSuffix());
+ }
+
+ @Test
+ public void testDotsAroundSuffix() {
+ RequestPathInfo p = createResourceUri("/libs/foo/content/something/formitems", ".json/image/vnd/xnd/knd.xml");
+ assertEquals("/libs/foo/content/something/formitems", p.getResourcePath());
+ assertEquals("json", p.getExtension());
+ assertNull("Selectors are null", p.getSelectorString());
+ assertEquals("/image/vnd/xnd/knd.xml", p.getSuffix());
+ }
+
+ @Test
+ public void testJIRA_250_a() {
+ RequestPathInfo p = createResourceUri("/bunkai", ".1.json");
+ assertEquals("/bunkai", p.getResourcePath());
+ assertEquals("json", p.getExtension());
+ assertEquals("1", p.getSelectorString());
+ }
+
+ @Test
+ public void testJIRA_250_b() {
+ RequestPathInfo p = createResourceUri("/", ".1.json");
+ assertEquals("/", p.getResourcePath());
+ assertEquals("json", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ assertEquals("Selector string must not be null", "1",
+ p.getSelectorString());
+ }
+
+ @Test
+ public void testJIRA_250_c() {
+ RequestPathInfo p = createResourceUri("/", ".1.json/my/suffix");
+ assertEquals("/", p.getResourcePath());
+ assertEquals("json", p.getExtension());
+ assertEquals("/my/suffix", p.getSuffix());
+ assertEquals("Selector string must not be null", "1",
+ p.getSelectorString());
+ }
+
+ @Test
+ public void testJIRA_250_d() {
+ RequestPathInfo p = createResourceUri("/", ".json");
+ assertEquals("/", p.getResourcePath());
+ assertEquals("json", p.getExtension());
+ assertNull("Suffix is null", p.getSuffix());
+ assertNull("Selectors are null", p.getSelectorString());
+ }
+
+}