src/test/java/org/apache/sling/resourceresolver/impl/EtcMappingResourceResolverTest.java - sling-org-apache-sling-resourceresolver - Git at Google

 /*
  * 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.resourceresolver.impl;

 import static java.util.Arrays.asList;
 import static org.apache.sling.resourceresolver.impl.MockedResourceResolverImplTest.createRPHandler;
 import static org.apache.sling.resourceresolver.impl.ResourceResolverImpl.PROP_REDIRECT_INTERNAL;
 import static org.apache.sling.resourceresolver.impl.mapping.MapEntries.PROP_REDIRECT_EXTERNAL;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.buildResource;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.callInaccessibleMethod;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.checkInternalResource;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.checkRedirectResource;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.createRequestFromUrl;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.createStringInterpolationProviderConfiguration;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.setInaccessibleField;
 import static org.apache.sling.resourceresolver.util.MockTestUtil.setupStringInterpolationProvider;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;

 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;

 import javax.servlet.http.HttpServletRequest;

 import org.apache.sling.api.resource.Resource;
 import org.apache.sling.api.resource.ResourceResolver;
 import org.apache.sling.api.resource.ResourceResolverFactory;
 import org.apache.sling.api.resource.observation.ResourceChange;
 import org.apache.sling.api.resource.path.Path;
 import org.apache.sling.resourceresolver.impl.mapping.MapConfigurationProvider;
 import org.apache.sling.resourceresolver.impl.mapping.MapEntries;
 import org.apache.sling.resourceresolver.impl.mapping.StringInterpolationProvider;
 import org.apache.sling.resourceresolver.impl.mapping.StringInterpolationProviderConfiguration;
 import org.apache.sling.resourceresolver.impl.mapping.StringInterpolationProviderImpl;
 import org.apache.sling.resourceresolver.impl.providers.ResourceProviderHandler;
 import org.apache.sling.resourceresolver.impl.providers.ResourceProviderStorage;
 import org.apache.sling.resourceresolver.impl.providers.ResourceProviderTracker;
 import org.apache.sling.resourceresolver.util.MockTestUtil;
 import org.apache.sling.resourceresolver.util.MockTestUtil.ExpectedEtcMapping;
 import org.apache.sling.serviceusermapping.ServiceUserMapper;
 import org.apache.sling.spi.resource.provider.ResourceProvider;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.service.event.EventAdmin;

 /**
  * These are the same tests as in the EtcMappingMapEntriesTest but in this
  * class we are actually mocking the Resource Resolver Factory and its classes
  * and we test the mapping and resource resolution through the resource resolver
  * rather the MapEntries.
  */
 public class EtcMappingResourceResolverTest {

     static final String PROP_REG_EXP = "sling:match";

     @Mock
     ResourceResolverFactory resourceResolverFactory;

     @Mock
     BundleContext bundleContext;

     @Mock
     Bundle bundle;

     @Mock
     EventAdmin eventAdmin;

     @Mock
     ResourceResolver resourceResolver;

     @Mock
     ResourceProvider<?> resourceProvider;

     StringInterpolationProviderConfiguration stringInterpolationProviderConfiguration;

     StringInterpolationProvider stringInterpolationProvider = new StringInterpolationProviderImpl();
     MapEntries mapEntries;

     File vanityBloomFilterFile;

     CommonResourceResolverFactoryImpl commonFactory;

     Resource etc;
     Resource map;
     Resource http;

     Map<String, Map<String, String>> aliasMap;

     @SuppressWarnings({"unchecked"})
     @Before
     public void setup() throws Exception {
         MockitoAnnotations.initMocks(this);

         List<MapConfigurationProvider.VanityPathConfig> configs = getVanityPathConfigs();
         vanityBloomFilterFile = new File("target/test-classes/resourcesvanityBloomFilter.txt");
         List<ResourceProviderHandler> handlers = asList(createRPHandler(resourceProvider, "rp1", 0, "/"));
         ResourceProviderTracker resourceProviderTracker = mock(ResourceProviderTracker.class);
         ResourceProviderStorage storage = new ResourceProviderStorage(handlers);
         when(resourceProviderTracker.getResourceProviderStorage()).thenReturn(storage);
         ResourceResolverFactoryActivator activator = new ResourceResolverFactoryActivator();
         // These fields on the Activator a package private so we need reflection to access them
         setInaccessibleField("resourceProviderTracker", activator, resourceProviderTracker);
         setInaccessibleField("resourceAccessSecurityTracker", activator, new ResourceAccessSecurityTracker());
         setInaccessibleField("bundleContext", activator, bundleContext);
         stringInterpolationProviderConfiguration = createStringInterpolationProviderConfiguration();
         setInaccessibleField("stringInterpolationProvider", activator, stringInterpolationProvider);
         setInaccessibleField("mapRoot", activator, "/etc/map");
         setInaccessibleField("mapRootPrefix", activator, "/etc/map");
         setInaccessibleField("observationPaths", activator, new Path[] {new Path("/")});
         ServiceUserMapper serviceUserMapper = mock(ServiceUserMapper.class);
         setInaccessibleField("serviceUserMapper", activator, serviceUserMapper);
         setInaccessibleField("pathToUriMappingService", activator, MockTestUtil.createPathToUriMappingServiceMock(resourceResolver));

         commonFactory = spy(new CommonResourceResolverFactoryImpl(activator));
         when(bundleContext.getBundle()).thenReturn(bundle);
         when(bundleContext.getDataFile("vanityBloomFilter.txt")).thenReturn(vanityBloomFilterFile);
         when(serviceUserMapper.getServiceUserID(any(Bundle.class),anyString())).thenReturn("mapping");
         // Activate method is package private so we use reflection to to call it
         callInaccessibleMethod("activate", null, commonFactory, BundleContext.class, bundleContext);
         final Bundle usingBundle = mock(Bundle.class);
         resourceResolverFactory = new ResourceResolverFactoryImpl(commonFactory, usingBundle, null);
         resourceResolver = resourceResolverFactory.getAdministrativeResourceResolver(null);

         etc = buildResource("/etc", null, resourceResolver, resourceProvider);
         map = buildResource("/etc/map", etc, resourceResolver, resourceProvider);
         http = buildResource("/etc/map/http", map, resourceResolver, resourceProvider);
     }

     List<MapConfigurationProvider.VanityPathConfig> getVanityPathConfigs() {
         return new ArrayList<>();
     }

     /**
      * Changes to the /etc/map in our tests are not taking effect until there is an Change Event issued
      *
      * ATTENTION: this method can only be issued once. After that the Resource Metadata is locked and
      * hence updates will fail
      *
      * @param path Path to the resource root to be refreshed
      * @param isExternal External flag of the ResourceChange event
      */
     void refreshMapEntries(String path, boolean isExternal) {
         ((MapEntries) commonFactory.getMapEntries()).onChange(
             asList(
                 new ResourceChange(ResourceChange.ChangeType.ADDED, path, isExternal)
             )
         );
     }

     @Test
     public void root_node_to_content_mapping() throws Exception {
         buildResource(http.getPath() + "/localhost.8080", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "/content/simple-node");
         // This updates the map entries so that the newly added resources are added.
         // ATTENTION: only call this after all etc-mapping resources are defined as this lock their Resource Meta Data and prevents a re-update
         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-node/");
         expectedEtcMapping.assertEtcMap("Etc Mapping for root node to content", commonFactory.getMapEntries().getResolveMaps());

         HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkRedirectResource(resolvedResource, "/content/simple-node/", 302);
     }

     @Test
     public void match_to_content_mapping() throws Exception {
         buildResource("test-node", http, resourceResolver, resourceProvider,
             PROP_REG_EXP, "localhost.8080/",
             PROP_REDIRECT_EXTERNAL, "/content/simple-match/"
         );
         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-match/");
         expectedEtcMapping.assertEtcMap("Etc Mapping for match to content", commonFactory.getMapEntries().getResolveMaps());

         HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkRedirectResource(resolvedResource, "/content/simple-match/", 302);
     }

     // The following tests are based on the example from the https://sling.apache.org/documentation/the-sling-engine/mappings-for-resource-resolution.html page

     @Test
     public void internal_to_external_node_mapping() throws Exception {
         buildResource("example.com.80", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "http://www.example.com/");
         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/example.com.80/", "http://www.example.com/");
         expectedEtcMapping.assertEtcMap("Etc Mapping for internal to external based on node", commonFactory.getMapEntries().getResolveMaps());

         HttpServletRequest request = createRequestFromUrl("http://example.com/");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkRedirectResource(resolvedResource, "http://www.example.com/", 302);
     }

     @Test
     public void internal_root_to_content_node_mapping() throws Exception {
         buildResource("/example", null, resourceResolver, resourceProvider);

         buildResource("www.example.com.80", http, resourceResolver, resourceProvider, PROP_REDIRECT_INTERNAL, "/example");
         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/www.example.com.80/", true, "/example/");
         expectedEtcMapping.assertEtcMap("Etc Mapping for internal root to content", commonFactory.getMapEntries().getResolveMaps());

         HttpServletRequest request = createRequestFromUrl("http://www.example.com:80/");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkInternalResource(resolvedResource, "/example");
     }

     @Test
     public void host_redirect_match_mapping() throws Exception {
         buildResource("any_example.com.80", http, resourceResolver, resourceProvider,
             PROP_REG_EXP, ".+\\.example\\.com\\.80",
             PROP_REDIRECT_EXTERNAL, "http://www.example.com/"
         );
         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/.+\\.example\\.com\\.80", false, "http://www.example.com/");
         expectedEtcMapping.assertEtcMap("Etc Mapping for host redirect match mapping", commonFactory.getMapEntries().getResolveMaps());

         HttpServletRequest request = createRequestFromUrl("http://www.example.com");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkRedirectResource(resolvedResource, "http://www.example.com//", 302);
     }

     @Test
     public void nested_internal_mixed_mapping() throws Exception {
         Resource localhost = buildResource("localhost_any", http, resourceResolver, resourceProvider,
             PROP_REG_EXP, "localhost\\.\\d*",
             PROP_REDIRECT_INTERNAL, "/content"
         );
         buildResource("cgi-bin", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "/scripts");
         buildResource("gateway", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "http://gbiv.com");
         buildResource("(stories)", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "/anecdotes/$1");

         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping()
             .addEtcMapEntry("^http/localhost\\.\\d*", true, "/content")
             .addEtcMapEntry("^http/localhost\\.\\d*/cgi-bin/", true, "/scripts/")
             .addEtcMapEntry("^http/localhost\\.\\d*/gateway/", true, "http://gbiv.com/")
             .addEtcMapEntry("^http/localhost\\.\\d*/(stories)/", true, "/anecdotes/$1/");
         expectedEtcMapping.assertEtcMap("Etc Mapping for nested internal mixed mapping", commonFactory.getMapEntries().getResolveMaps());

         buildResource("/content", null, resourceResolver, resourceProvider);
         Resource scripts = buildResource("/scripts", null, resourceResolver, resourceProvider);
         Resource scriptsChild = buildResource("/scripts/child", scripts, resourceResolver, resourceProvider);
         Resource anecdotes = buildResource("/anecdotes", null, resourceResolver, resourceProvider);
         Resource stories = buildResource("/anecdotes/stories", anecdotes, resourceResolver, resourceProvider);

         HttpServletRequest request = createRequestFromUrl("http://localhost:1234/");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkInternalResource(resolvedResource, "/content");

         resolvedResource = resourceResolver.resolve(request, "/cgi-bin/");
         checkInternalResource(resolvedResource, "/scripts");
         resolvedResource = resourceResolver.resolve(request, "/cgi-bin/child/");
         checkInternalResource(resolvedResource, "/scripts/child");
 //AS TODO: Does not redirect -> investigate later
 //        resolvedResource = resourceResolver.resolve(request, "/gateway/");
 //        checkRedirectResource(resolvedResource, "http://gbiv.com/", 302);
         resolvedResource = resourceResolver.resolve(request, "/stories/");
         checkInternalResource(resolvedResource, "/anecdotes/stories");
     }

     @Test
     public void simple_node_string_interpolation() throws Exception {
         buildResource("$[config:siv.one]", http, resourceResolver, resourceProvider,PROP_REDIRECT_EXTERNAL, "/content/simple-node");
         setupStringInterpolationProvider(stringInterpolationProvider, stringInterpolationProviderConfiguration, new String[] {"siv.one=test-simple-node.80"});

         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/test-simple-node.80/", "/content/simple-node/");
         expectedEtcMapping.assertEtcMap("String Interpolation for simple match", commonFactory.getMapEntries().getResolveMaps());

         Resource content = buildResource("/content", null, resourceResolver, resourceProvider);
         Resource simpleNode = buildResource("/content/simple-node", content, resourceResolver, resourceProvider);

         HttpServletRequest request = createRequestFromUrl("http://test-simple-node:80/");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkRedirectResource(resolvedResource, "/content/simple-node/", 302);
     }

     @Test
     public void simple_match_string_interpolation() throws Exception {
         buildResource("test-node", http, resourceResolver, resourceProvider,
             PROP_REG_EXP, "$[config:siv.one]/",
             PROP_REDIRECT_EXTERNAL, "/content/simple-match/"
         );
         setupStringInterpolationProvider(stringInterpolationProvider, stringInterpolationProviderConfiguration, new String[] {"siv.one=test-simple-match.80"});

         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/test-simple-match.80/", "/content/simple-match/");
         expectedEtcMapping.assertEtcMap("String Interpolation for simple match", commonFactory.getMapEntries().getResolveMaps());

         HttpServletRequest request = createRequestFromUrl("http://test-simple-match:80/");
         Resource resolvedResource = resourceResolver.resolve(request, "/");
         checkRedirectResource(resolvedResource, "/content/simple-match/", 302);
     }

     /**
      * ATTENTION: this tests showcases an erroneous condition of an endless circular mapping in the /etc/map. When
      * this test passes this condition is present. After a fix this test must be adjusted.
      *
      * This confirms an issue with the Etc Mapping where a mapping from a node to a child node (here / to /content)
      * ends up in a endless circular mapping.
      * The only way to recover from this is to go to the OSGi console and change the /etc/map path in the Resource
      * Resolver factory.
      * Either the Etc Mapping discovers this condition and stops it or at least ignores mapping for Composum to allow
      * the /etc/map to be edited.
      */
     @Test
     public void endless_circular_mapping() throws Exception {
         buildResource(http.getPath() + "/localhost.8080", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "/content");
         refreshMapEntries("/etc/map", true);

         ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/");
         expectedEtcMapping.assertEtcMap("Etc Mapping for root node to content", commonFactory.getMapEntries().getResolveMaps());

         buildResource("/content/test", null, resourceResolver, resourceProvider);
         buildResource("/content/content/test", null, resourceResolver, resourceProvider);
         buildResource("/content/content/content/test", null, resourceResolver, resourceProvider);

         HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
         Resource resolvedResource = resourceResolver.resolve(request, "/test.html");
         checkRedirectResource(resolvedResource, "/content/test.html", 302);

         resolvedResource = resourceResolver.resolve(request, "/content/test.html");
         checkRedirectResource(resolvedResource, "/content/content/test.html", 302);

         resolvedResource = resourceResolver.resolve(request, "/content/content/test.html");
         checkRedirectResource(resolvedResource, "/content/content/content/test.html", 302);
     }
 }
	/*
	* 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.resourceresolver.impl;

	import static java.util.Arrays.asList;
	import static org.apache.sling.resourceresolver.impl.MockedResourceResolverImplTest.createRPHandler;
	import static org.apache.sling.resourceresolver.impl.ResourceResolverImpl.PROP_REDIRECT_INTERNAL;
	import static org.apache.sling.resourceresolver.impl.mapping.MapEntries.PROP_REDIRECT_EXTERNAL;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.buildResource;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.callInaccessibleMethod;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.checkInternalResource;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.checkRedirectResource;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.createRequestFromUrl;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.createStringInterpolationProviderConfiguration;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.setInaccessibleField;
	import static org.apache.sling.resourceresolver.util.MockTestUtil.setupStringInterpolationProvider;
	import static org.mockito.Matchers.any;
	import static org.mockito.Matchers.anyString;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.spy;
	import static org.mockito.Mockito.when;

	import java.io.File;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;

	import javax.servlet.http.HttpServletRequest;

	import org.apache.sling.api.resource.Resource;
	import org.apache.sling.api.resource.ResourceResolver;
	import org.apache.sling.api.resource.ResourceResolverFactory;
	import org.apache.sling.api.resource.observation.ResourceChange;
	import org.apache.sling.api.resource.path.Path;
	import org.apache.sling.resourceresolver.impl.mapping.MapConfigurationProvider;
	import org.apache.sling.resourceresolver.impl.mapping.MapEntries;
	import org.apache.sling.resourceresolver.impl.mapping.StringInterpolationProvider;
	import org.apache.sling.resourceresolver.impl.mapping.StringInterpolationProviderConfiguration;
	import org.apache.sling.resourceresolver.impl.mapping.StringInterpolationProviderImpl;
	import org.apache.sling.resourceresolver.impl.providers.ResourceProviderHandler;
	import org.apache.sling.resourceresolver.impl.providers.ResourceProviderStorage;
	import org.apache.sling.resourceresolver.impl.providers.ResourceProviderTracker;
	import org.apache.sling.resourceresolver.util.MockTestUtil;
	import org.apache.sling.resourceresolver.util.MockTestUtil.ExpectedEtcMapping;
	import org.apache.sling.serviceusermapping.ServiceUserMapper;
	import org.apache.sling.spi.resource.provider.ResourceProvider;
	import org.junit.Before;
	import org.junit.Test;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.BundleContext;
	import org.osgi.service.event.EventAdmin;

	/**
	* These are the same tests as in the EtcMappingMapEntriesTest but in this
	* class we are actually mocking the Resource Resolver Factory and its classes
	* and we test the mapping and resource resolution through the resource resolver
	* rather the MapEntries.
	*/
	public class EtcMappingResourceResolverTest {

	static final String PROP_REG_EXP = "sling:match";

	@Mock
	ResourceResolverFactory resourceResolverFactory;

	@Mock
	BundleContext bundleContext;

	@Mock
	Bundle bundle;

	@Mock
	EventAdmin eventAdmin;

	@Mock
	ResourceResolver resourceResolver;

	@Mock
	ResourceProvider<?> resourceProvider;

	StringInterpolationProviderConfiguration stringInterpolationProviderConfiguration;

	StringInterpolationProvider stringInterpolationProvider = new StringInterpolationProviderImpl();
	MapEntries mapEntries;

	File vanityBloomFilterFile;

	CommonResourceResolverFactoryImpl commonFactory;

	Resource etc;
	Resource map;
	Resource http;

	Map<String, Map<String, String>> aliasMap;

	@SuppressWarnings({"unchecked"})
	@Before
	public void setup() throws Exception {
	MockitoAnnotations.initMocks(this);

	List<MapConfigurationProvider.VanityPathConfig> configs = getVanityPathConfigs();
	vanityBloomFilterFile = new File("target/test-classes/resourcesvanityBloomFilter.txt");
	List<ResourceProviderHandler> handlers = asList(createRPHandler(resourceProvider, "rp1", 0, "/"));
	ResourceProviderTracker resourceProviderTracker = mock(ResourceProviderTracker.class);
	ResourceProviderStorage storage = new ResourceProviderStorage(handlers);
	when(resourceProviderTracker.getResourceProviderStorage()).thenReturn(storage);
	ResourceResolverFactoryActivator activator = new ResourceResolverFactoryActivator();
	// These fields on the Activator a package private so we need reflection to access them
	setInaccessibleField("resourceProviderTracker", activator, resourceProviderTracker);
	setInaccessibleField("resourceAccessSecurityTracker", activator, new ResourceAccessSecurityTracker());
	setInaccessibleField("bundleContext", activator, bundleContext);
	stringInterpolationProviderConfiguration = createStringInterpolationProviderConfiguration();
	setInaccessibleField("stringInterpolationProvider", activator, stringInterpolationProvider);
	setInaccessibleField("mapRoot", activator, "/etc/map");
	setInaccessibleField("mapRootPrefix", activator, "/etc/map");
	setInaccessibleField("observationPaths", activator, new Path[] {new Path("/")});
	ServiceUserMapper serviceUserMapper = mock(ServiceUserMapper.class);
	setInaccessibleField("serviceUserMapper", activator, serviceUserMapper);
	setInaccessibleField("pathToUriMappingService", activator, MockTestUtil.createPathToUriMappingServiceMock(resourceResolver));

	commonFactory = spy(new CommonResourceResolverFactoryImpl(activator));
	when(bundleContext.getBundle()).thenReturn(bundle);
	when(bundleContext.getDataFile("vanityBloomFilter.txt")).thenReturn(vanityBloomFilterFile);
	when(serviceUserMapper.getServiceUserID(any(Bundle.class),anyString())).thenReturn("mapping");
	// Activate method is package private so we use reflection to to call it
	callInaccessibleMethod("activate", null, commonFactory, BundleContext.class, bundleContext);
	final Bundle usingBundle = mock(Bundle.class);
	resourceResolverFactory = new ResourceResolverFactoryImpl(commonFactory, usingBundle, null);
	resourceResolver = resourceResolverFactory.getAdministrativeResourceResolver(null);

	etc = buildResource("/etc", null, resourceResolver, resourceProvider);
	map = buildResource("/etc/map", etc, resourceResolver, resourceProvider);
	http = buildResource("/etc/map/http", map, resourceResolver, resourceProvider);
	}

	List<MapConfigurationProvider.VanityPathConfig> getVanityPathConfigs() {
	return new ArrayList<>();
	}

	/**
	* Changes to the /etc/map in our tests are not taking effect until there is an Change Event issued
	*
	* ATTENTION: this method can only be issued once. After that the Resource Metadata is locked and
	* hence updates will fail
	*
	* @param path Path to the resource root to be refreshed
	* @param isExternal External flag of the ResourceChange event
	*/
	void refreshMapEntries(String path, boolean isExternal) {
	((MapEntries) commonFactory.getMapEntries()).onChange(
	asList(
	new ResourceChange(ResourceChange.ChangeType.ADDED, path, isExternal)
	)
	);
	}

	@Test
	public void root_node_to_content_mapping() throws Exception {
	buildResource(http.getPath() + "/localhost.8080", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "/content/simple-node");
	// This updates the map entries so that the newly added resources are added.
	// ATTENTION: only call this after all etc-mapping resources are defined as this lock their Resource Meta Data and prevents a re-update
	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-node/");
	expectedEtcMapping.assertEtcMap("Etc Mapping for root node to content", commonFactory.getMapEntries().getResolveMaps());

	HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkRedirectResource(resolvedResource, "/content/simple-node/", 302);
	}

	@Test
	public void match_to_content_mapping() throws Exception {
	buildResource("test-node", http, resourceResolver, resourceProvider,
	PROP_REG_EXP, "localhost.8080/",
	PROP_REDIRECT_EXTERNAL, "/content/simple-match/"
	);
	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-match/");
	expectedEtcMapping.assertEtcMap("Etc Mapping for match to content", commonFactory.getMapEntries().getResolveMaps());

	HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkRedirectResource(resolvedResource, "/content/simple-match/", 302);
	}

	// The following tests are based on the example from the https://sling.apache.org/documentation/the-sling-engine/mappings-for-resource-resolution.html page

	@Test
	public void internal_to_external_node_mapping() throws Exception {
	buildResource("example.com.80", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "http://www.example.com/");
	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/example.com.80/", "http://www.example.com/");
	expectedEtcMapping.assertEtcMap("Etc Mapping for internal to external based on node", commonFactory.getMapEntries().getResolveMaps());

	HttpServletRequest request = createRequestFromUrl("http://example.com/");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkRedirectResource(resolvedResource, "http://www.example.com/", 302);
	}

	@Test
	public void internal_root_to_content_node_mapping() throws Exception {
	buildResource("/example", null, resourceResolver, resourceProvider);

	buildResource("www.example.com.80", http, resourceResolver, resourceProvider, PROP_REDIRECT_INTERNAL, "/example");
	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/www.example.com.80/", true, "/example/");
	expectedEtcMapping.assertEtcMap("Etc Mapping for internal root to content", commonFactory.getMapEntries().getResolveMaps());

	HttpServletRequest request = createRequestFromUrl("http://www.example.com:80/");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkInternalResource(resolvedResource, "/example");
	}

	@Test
	public void host_redirect_match_mapping() throws Exception {
	buildResource("any_example.com.80", http, resourceResolver, resourceProvider,
	PROP_REG_EXP, ".+\\.example\\.com\\.80",
	PROP_REDIRECT_EXTERNAL, "http://www.example.com/"
	);
	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/.+\\.example\\.com\\.80", false, "http://www.example.com/");
	expectedEtcMapping.assertEtcMap("Etc Mapping for host redirect match mapping", commonFactory.getMapEntries().getResolveMaps());

	HttpServletRequest request = createRequestFromUrl("http://www.example.com");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkRedirectResource(resolvedResource, "http://www.example.com//", 302);
	}

	@Test
	public void nested_internal_mixed_mapping() throws Exception {
	Resource localhost = buildResource("localhost_any", http, resourceResolver, resourceProvider,
	PROP_REG_EXP, "localhost\\.\\d*",
	PROP_REDIRECT_INTERNAL, "/content"
	);
	buildResource("cgi-bin", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "/scripts");
	buildResource("gateway", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "http://gbiv.com");
	buildResource("(stories)", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "/anecdotes/$1");

	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping()
	.addEtcMapEntry("^http/localhost\\.\\d*", true, "/content")
	.addEtcMapEntry("^http/localhost\\.\\d*/cgi-bin/", true, "/scripts/")
	.addEtcMapEntry("^http/localhost\\.\\d*/gateway/", true, "http://gbiv.com/")
	.addEtcMapEntry("^http/localhost\\.\\d*/(stories)/", true, "/anecdotes/$1/");
	expectedEtcMapping.assertEtcMap("Etc Mapping for nested internal mixed mapping", commonFactory.getMapEntries().getResolveMaps());

	buildResource("/content", null, resourceResolver, resourceProvider);
	Resource scripts = buildResource("/scripts", null, resourceResolver, resourceProvider);
	Resource scriptsChild = buildResource("/scripts/child", scripts, resourceResolver, resourceProvider);
	Resource anecdotes = buildResource("/anecdotes", null, resourceResolver, resourceProvider);
	Resource stories = buildResource("/anecdotes/stories", anecdotes, resourceResolver, resourceProvider);

	HttpServletRequest request = createRequestFromUrl("http://localhost:1234/");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkInternalResource(resolvedResource, "/content");

	resolvedResource = resourceResolver.resolve(request, "/cgi-bin/");
	checkInternalResource(resolvedResource, "/scripts");
	resolvedResource = resourceResolver.resolve(request, "/cgi-bin/child/");
	checkInternalResource(resolvedResource, "/scripts/child");
	//AS TODO: Does not redirect -> investigate later
	// resolvedResource = resourceResolver.resolve(request, "/gateway/");
	// checkRedirectResource(resolvedResource, "http://gbiv.com/", 302);
	resolvedResource = resourceResolver.resolve(request, "/stories/");
	checkInternalResource(resolvedResource, "/anecdotes/stories");
	}

	@Test
	public void simple_node_string_interpolation() throws Exception {
	buildResource("$[config:siv.one]", http, resourceResolver, resourceProvider,PROP_REDIRECT_EXTERNAL, "/content/simple-node");
	setupStringInterpolationProvider(stringInterpolationProvider, stringInterpolationProviderConfiguration, new String[] {"siv.one=test-simple-node.80"});

	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/test-simple-node.80/", "/content/simple-node/");
	expectedEtcMapping.assertEtcMap("String Interpolation for simple match", commonFactory.getMapEntries().getResolveMaps());

	Resource content = buildResource("/content", null, resourceResolver, resourceProvider);
	Resource simpleNode = buildResource("/content/simple-node", content, resourceResolver, resourceProvider);

	HttpServletRequest request = createRequestFromUrl("http://test-simple-node:80/");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkRedirectResource(resolvedResource, "/content/simple-node/", 302);
	}

	@Test
	public void simple_match_string_interpolation() throws Exception {
	buildResource("test-node", http, resourceResolver, resourceProvider,
	PROP_REG_EXP, "$[config:siv.one]/",
	PROP_REDIRECT_EXTERNAL, "/content/simple-match/"
	);
	setupStringInterpolationProvider(stringInterpolationProvider, stringInterpolationProviderConfiguration, new String[] {"siv.one=test-simple-match.80"});

	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/test-simple-match.80/", "/content/simple-match/");
	expectedEtcMapping.assertEtcMap("String Interpolation for simple match", commonFactory.getMapEntries().getResolveMaps());

	HttpServletRequest request = createRequestFromUrl("http://test-simple-match:80/");
	Resource resolvedResource = resourceResolver.resolve(request, "/");
	checkRedirectResource(resolvedResource, "/content/simple-match/", 302);
	}

	/**
	* ATTENTION: this tests showcases an erroneous condition of an endless circular mapping in the /etc/map. When
	* this test passes this condition is present. After a fix this test must be adjusted.
	*
	* This confirms an issue with the Etc Mapping where a mapping from a node to a child node (here / to /content)
	* ends up in a endless circular mapping.
	* The only way to recover from this is to go to the OSGi console and change the /etc/map path in the Resource
	* Resolver factory.
	* Either the Etc Mapping discovers this condition and stops it or at least ignores mapping for Composum to allow
	* the /etc/map to be edited.
	*/
	@Test
	public void endless_circular_mapping() throws Exception {
	buildResource(http.getPath() + "/localhost.8080", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "/content");
	refreshMapEntries("/etc/map", true);

	ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/");
	expectedEtcMapping.assertEtcMap("Etc Mapping for root node to content", commonFactory.getMapEntries().getResolveMaps());

	buildResource("/content/test", null, resourceResolver, resourceProvider);
	buildResource("/content/content/test", null, resourceResolver, resourceProvider);
	buildResource("/content/content/content/test", null, resourceResolver, resourceProvider);

	HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
	Resource resolvedResource = resourceResolver.resolve(request, "/test.html");
	checkRedirectResource(resolvedResource, "/content/test.html", 302);

	resolvedResource = resourceResolver.resolve(request, "/content/test.html");
	checkRedirectResource(resolvedResource, "/content/content/test.html", 302);

	resolvedResource = resourceResolver.resolve(request, "/content/content/test.html");
	checkRedirectResource(resolvedResource, "/content/content/content/test.html", 302);
	}
	}