src/test/java/org/apache/sling/superimposing/impl/SuperimposingManagerImplTest.java - sling-org-apache-sling-superimposing - 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.superimposing.impl;

 import static org.apache.sling.superimposing.SuperimposingResourceProvider.PROP_SUPERIMPOSE_OVERLAYABLE;
 import static org.apache.sling.superimposing.SuperimposingResourceProvider.PROP_SUPERIMPOSE_REGISTER_PARENT;
 import static org.apache.sling.superimposing.SuperimposingResourceProvider.PROP_SUPERIMPOSE_SOURCE_PATH;
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Dictionary;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import javax.jcr.PathNotFoundException;
 import javax.jcr.Property;
 import javax.jcr.RepositoryException;
 import javax.jcr.Session;
 import javax.jcr.observation.Event;
 import javax.jcr.observation.EventIterator;
 import javax.jcr.observation.EventListener;

 import org.apache.commons.collections.IteratorUtils;
 import org.apache.sling.api.resource.LoginException;
 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.ResourceUtil;
 import org.apache.sling.api.resource.ValueMap;
 import org.apache.sling.api.wrappers.ValueMapDecorator;
 import org.apache.sling.superimposing.SuperimposingResourceProvider;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.mockito.stubbing.Answer;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.component.ComponentContext;

 @RunWith(MockitoJUnitRunner.class)
 public class SuperimposingManagerImplTest {

     @Mock
     private Dictionary<String, Object> componentContextProperties;
     @Mock
     private ComponentContext componentContext;
     @Mock
     private BundleContext bundleContext;
     @Mock
     private ResourceResolverFactory resourceResolverFactory;
     @Mock
     private ResourceResolver resourceResolver;
     @Mock(answer=Answers.RETURNS_DEEP_STUBS)
     private Session session;
     private List<ServiceRegistration> serviceRegistrations = new ArrayList<ServiceRegistration>();

     private SuperimposingManagerImpl underTest;

     private static final String ORIGINAL_PATH = "/root/path1";
     private static final String SUPERIMPOSED_PATH = "/root/path2";
     private static final String OBSERVATION_PATH = "/root";

     @SuppressWarnings("unchecked")
     @Before
     public void setUp() throws LoginException {
         when(componentContext.getBundleContext()).thenReturn(bundleContext);
         when(componentContext.getProperties()).thenReturn(componentContextProperties);
         when(componentContextProperties.get(SuperimposingManagerImpl.OBSERVATION_PATHS_PROPERTY)).thenReturn(new String[] { OBSERVATION_PATH });
         when(resourceResolverFactory.getAdministrativeResourceResolver(any(Map.class))).thenReturn(resourceResolver);
         when(resourceResolver.adaptTo(Session.class)).thenReturn(session);

         // collect a list of all service registrations to validate that they are all unregistered on shutdown
         when(bundleContext.registerService(anyString(), anyObject(), any(Dictionary.class))).thenAnswer(new Answer<ServiceRegistration>() {
             public ServiceRegistration answer(InvocationOnMock invocation) {
                 final ServiceRegistration mockRegistration = mock(ServiceRegistration.class);
                 serviceRegistrations.add(mockRegistration);
                 doAnswer(new Answer() {
                     public Object answer(InvocationOnMock invocation) {
                         return serviceRegistrations.remove(mockRegistration);
                     }
                 }).when(mockRegistration).unregister();
                 return mockRegistration;
             }
         });

         // simulate absolute path access to properties via session object
         try {
             when(session.itemExists(anyString())).thenAnswer(new Answer<Boolean>() {
                 public Boolean answer(InvocationOnMock invocation) throws Throwable {
                     final String absolutePath = (String)invocation.getArguments()[0];
                     final String nodePath = ResourceUtil.getParent(absolutePath);
                     final String propertyName = ResourceUtil.getName(absolutePath);
                     Resource resource = resourceResolver.getResource(nodePath);
                     if (resource!=null) {
                         ValueMap props = resource.adaptTo(ValueMap.class);
                         return props.containsKey(propertyName);
                     }
                     else {
                         return false;
                     }
                 }
             });
             when(session.getProperty(anyString())).thenAnswer(new Answer<Property>() {
                 public Property answer(InvocationOnMock invocation) throws Throwable {
                     final String absolutePath = (String)invocation.getArguments()[0];
                     final String nodePath = ResourceUtil.getParent(absolutePath);
                     final String propertyName = ResourceUtil.getName(absolutePath);
                     Resource resource = resourceResolver.getResource(nodePath);
                     if (resource!=null) {
                         ValueMap props = resource.adaptTo(ValueMap.class);
                         Object value = props.get(propertyName);
                         if (value==null) {
                             throw new PathNotFoundException();
                         }
                         Property prop = mock(Property.class);
                         when(prop.getName()).thenReturn(propertyName);
                         if (value instanceof String) {
                             when(prop.getString()).thenReturn((String)value);
                         }
                         else if (value instanceof Boolean) {
                             when(prop.getBoolean()).thenReturn((Boolean)value);
                         }
                         return prop;
                     }
                     else {
                         throw new PathNotFoundException();
                     }
                 }
             });
         }
         catch (RepositoryException ex) {
             throw new RuntimeException(ex);
         }
     }

     private void initialize(boolean enabled) throws InterruptedException, LoginException, RepositoryException {
         when(componentContextProperties.get(SuperimposingManagerImpl.ENABLED_PROPERTY)).thenReturn(enabled);

         underTest = new SuperimposingManagerImpl().withResourceResolverFactory(resourceResolverFactory);
         underTest.activate(componentContext);

         if (underTest.isEnabled()) {
             // verify observation registration
             verify(session.getWorkspace().getObservationManager()).addEventListener(any(EventListener.class), anyInt(), eq(OBSERVATION_PATH), anyBoolean(), any(String[].class), any(String[].class), anyBoolean());
             // wait until separate initialization thread has finished
             while (!underTest.initialization.isDone()) {
                 Thread.sleep(10);
             }
         }
     }

     @After
     public void tearDown() throws RepositoryException {
         underTest.deactivate(componentContext);

         if (underTest.isEnabled()) {
             // verify observation and resource resolver are terminated correctly
             verify(session.getWorkspace().getObservationManager()).removeEventListener(any(EventListener.class));
             verify(resourceResolver).close();
         }

         // make sure all registrations are unregistered on shutdown
         for (ServiceRegistration registration : serviceRegistrations) {
             verify(registration, times(1)).unregister();
         }
     }

     private Resource prepareSuperimposingResource(String superimposedPath, String sourcePath, boolean registerParent, boolean overlayable) {
         Resource resource = mock(Resource.class);
         when(resource.getPath()).thenReturn(superimposedPath);
         ValueMap props = new ValueMapDecorator(new HashMap<String, Object>());
         props.put(PROP_SUPERIMPOSE_SOURCE_PATH, sourcePath);
         props.put(PROP_SUPERIMPOSE_REGISTER_PARENT, registerParent);
         props.put(PROP_SUPERIMPOSE_OVERLAYABLE, overlayable);
         when(resource.adaptTo(ValueMap.class)).thenReturn(props);
         when(resourceResolver.getResource(superimposedPath)).thenReturn(resource);
         return resource;
     }

     private void moveSuperimposedResource(Resource resource, String newPath) {
         String oldPath = resource.getPath();
         when(resource.getPath()).thenReturn(newPath);
         when(resourceResolver.getResource(oldPath)).thenReturn(null);
         when(resourceResolver.getResource(newPath)).thenReturn(resource);
     }

     @Test
     public void testDisabled() throws InterruptedException, LoginException, RepositoryException {
         // make sure that no exception is thrown when service is disabled on activate/deactivate
         initialize(false);

         verifyZeroInteractions(resourceResolverFactory);
         verifyZeroInteractions(bundleContext);
     }

     @SuppressWarnings("unchecked")
     @Test
     public void testFindAllSuperimposings() throws InterruptedException, LoginException, RepositoryException {
         // prepare a query that returns one existing superimposed resource
         when(componentContextProperties.get(SuperimposingManagerImpl.FINDALLQUERIES_PROPERTY)).thenReturn("syntax|query");
         when(resourceResolver.findResources("query", "syntax")).then(new Answer<Iterator<Resource>>() {
             public Iterator<Resource> answer(InvocationOnMock invocation) {
                 return Arrays.asList(new Resource[] {
                         prepareSuperimposingResource(SUPERIMPOSED_PATH, ORIGINAL_PATH, false, false)
                 }).iterator();
             }
         });
         initialize(true);

         // ensure the superimposed resource is detected and registered
         List<SuperimposingResourceProvider> providers = IteratorUtils.toList(underTest.getRegisteredProviders());
         assertEquals(1, providers.size());
         SuperimposingResourceProvider provider = providers.iterator().next();
         assertEquals(SUPERIMPOSED_PATH, provider.getRootPath());
         assertEquals(ORIGINAL_PATH, provider.getSourcePath());
         assertFalse(provider.isOverlayable());
         verify(bundleContext).registerService(anyString(), same(provider), any(Dictionary.class));
     }

     private EventIterator prepareNodeCreateEvent(Resource pResource) throws RepositoryException {
         String resourcePath = pResource.getPath();

         Event nodeEvent = mock(Event.class);
         when(nodeEvent.getType()).thenReturn(Event.NODE_ADDED);
         when(nodeEvent.getPath()).thenReturn(resourcePath);

         Event propertyEvent = mock(Event.class);
         when(propertyEvent.getType()).thenReturn(Event.PROPERTY_ADDED);
         when(propertyEvent.getPath()).thenReturn(resourcePath + "/" + SuperimposingResourceProvider.PROP_SUPERIMPOSE_SOURCE_PATH);

         EventIterator eventIterator = mock(EventIterator.class);
         when(eventIterator.hasNext()).thenReturn(true, true, false);
         when(eventIterator.nextEvent()).thenReturn(nodeEvent, propertyEvent);
         return eventIterator;
     }

     private EventIterator prepareNodeChangeEvent(Resource pResource) throws RepositoryException {
         String resourcePath = pResource.getPath();

         Event propertyEvent = mock(Event.class);
         when(propertyEvent.getType()).thenReturn(Event.PROPERTY_CHANGED);
         when(propertyEvent.getPath()).thenReturn(resourcePath + "/" + SuperimposingResourceProvider.PROP_SUPERIMPOSE_SOURCE_PATH);

         EventIterator eventIterator = mock(EventIterator.class);
         when(eventIterator.hasNext()).thenReturn(true, false);
         when(eventIterator.nextEvent()).thenReturn(propertyEvent);
         return eventIterator;
     }

     private EventIterator prepareNodeRemoveEvent(Resource pResource) throws RepositoryException {
         String resourcePath = pResource.getPath();

         Event nodeEvent = mock(Event.class);
         when(nodeEvent.getType()).thenReturn(Event.NODE_REMOVED);
         when(nodeEvent.getPath()).thenReturn(resourcePath);

         EventIterator eventIterator = mock(EventIterator.class);
         when(eventIterator.hasNext()).thenReturn(true, false);
         when(eventIterator.nextEvent()).thenReturn(nodeEvent);
         return eventIterator;
     }

     private EventIterator prepareNodeMoveEvent(Resource pResource, String pOldPath) throws RepositoryException {
         String resourcePath = pResource.getPath();

         Event nodeRemoveEvent = mock(Event.class);
         when(nodeRemoveEvent.getType()).thenReturn(Event.NODE_REMOVED);
         when(nodeRemoveEvent.getPath()).thenReturn(pOldPath);

         Event nodeCreateEvent = mock(Event.class);
         when(nodeCreateEvent.getType()).thenReturn(Event.NODE_ADDED);
         when(nodeCreateEvent.getPath()).thenReturn(resourcePath);

         EventIterator eventIterator = mock(EventIterator.class);
         when(eventIterator.hasNext()).thenReturn(true, true, false);
         when(eventIterator.nextEvent()).thenReturn(nodeRemoveEvent, nodeCreateEvent);
         return eventIterator;
     }

     @SuppressWarnings("unchecked")
     @Test
     public void testSuperimposedResourceCreateUpdateRemove() throws InterruptedException, LoginException, RepositoryException {
         initialize(true);

         // simulate node create event
         Resource superimposedResource = prepareSuperimposingResource(SUPERIMPOSED_PATH, ORIGINAL_PATH, false, false);
         underTest.onEvent(prepareNodeCreateEvent(superimposedResource));

         // ensure the superimposed resource is detected and registered
         List<SuperimposingResourceProvider> providers = IteratorUtils.toList(underTest.getRegisteredProviders());
         assertEquals(1, providers.size());
         SuperimposingResourceProvider provider = providers.iterator().next();
         assertEquals(SUPERIMPOSED_PATH, provider.getRootPath());
         assertEquals(ORIGINAL_PATH, provider.getSourcePath());
         assertFalse(provider.isOverlayable());
         verify(bundleContext).registerService(anyString(), same(provider), any(Dictionary.class));

         // simulate a change in the original path
         superimposedResource.adaptTo(ValueMap.class).put(PROP_SUPERIMPOSE_SOURCE_PATH, "/other/path");
         underTest.onEvent(prepareNodeChangeEvent(superimposedResource));

         // ensure the superimposed resource update is detected and a new provider instance is registered
         providers = IteratorUtils.toList(underTest.getRegisteredProviders());
         assertEquals(1, providers.size());
         SuperimposingResourceProvider provider2 = providers.iterator().next();
         assertEquals(SUPERIMPOSED_PATH, provider2.getRootPath());
         assertEquals("/other/path", provider2.getSourcePath());
         assertFalse(provider2.isOverlayable());
         verify(bundleContext).registerService(anyString(), same(provider2), any(Dictionary.class));

         // simulate node removal
         underTest.onEvent(prepareNodeRemoveEvent(superimposedResource));

         // ensure provider is removed
         providers = IteratorUtils.toList(underTest.getRegisteredProviders());
         assertEquals(0, providers.size());
     }

     @SuppressWarnings("unchecked")
     @Test
     public void testSuperimposedResourceCreateMove() throws InterruptedException, LoginException, RepositoryException {
         when(componentContextProperties.get(SuperimposingManagerImpl.FINDALLQUERIES_PROPERTY)).thenReturn("syntax|query");
         initialize(true);

         // simulate node create event
         final Resource superimposedResource = prepareSuperimposingResource(SUPERIMPOSED_PATH, ORIGINAL_PATH, false, false);
         underTest.onEvent(prepareNodeCreateEvent(superimposedResource));

         // simulate a node move event
         String oldPath = superimposedResource.getPath();
         moveSuperimposedResource(superimposedResource, "/new/path");

         // prepare a query that returns the moved superimposed resource
         when(resourceResolver.findResources("query", "syntax")).then(new Answer<Iterator<Resource>>() {
             public Iterator<Resource> answer(InvocationOnMock invocation) {
                 return Arrays.asList(new Resource[] {
                         superimposedResource
                 }).iterator();
             }
         });

         underTest.onEvent(prepareNodeMoveEvent(superimposedResource, oldPath));

         // ensure the superimposed resource update is detected and a new provider instance is registered
         List<SuperimposingResourceProvider> providers = IteratorUtils.toList(underTest.getRegisteredProviders());
         assertEquals(1, providers.size());
         SuperimposingResourceProvider provider = providers.iterator().next();
         assertEquals("/new/path", provider.getRootPath());
         assertEquals(ORIGINAL_PATH, provider.getSourcePath());
         assertFalse(provider.isOverlayable());
         verify(bundleContext).registerService(anyString(), same(provider), any(Dictionary.class));
     }

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

	import static org.apache.sling.superimposing.SuperimposingResourceProvider.PROP_SUPERIMPOSE_OVERLAYABLE;
	import static org.apache.sling.superimposing.SuperimposingResourceProvider.PROP_SUPERIMPOSE_REGISTER_PARENT;
	import static org.apache.sling.superimposing.SuperimposingResourceProvider.PROP_SUPERIMPOSE_SOURCE_PATH;
	import static org.junit.Assert.*;
	import static org.mockito.Mockito.*;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Dictionary;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import javax.jcr.PathNotFoundException;
	import javax.jcr.Property;
	import javax.jcr.RepositoryException;
	import javax.jcr.Session;
	import javax.jcr.observation.Event;
	import javax.jcr.observation.EventIterator;
	import javax.jcr.observation.EventListener;

	import org.apache.commons.collections.IteratorUtils;
	import org.apache.sling.api.resource.LoginException;
	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.ResourceUtil;
	import org.apache.sling.api.resource.ValueMap;
	import org.apache.sling.api.wrappers.ValueMapDecorator;
	import org.apache.sling.superimposing.SuperimposingResourceProvider;
	import org.junit.After;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.Answers;
	import org.mockito.Mock;
	import org.mockito.invocation.InvocationOnMock;
	import org.mockito.runners.MockitoJUnitRunner;
	import org.mockito.stubbing.Answer;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.ServiceRegistration;
	import org.osgi.service.component.ComponentContext;

	@RunWith(MockitoJUnitRunner.class)
	public class SuperimposingManagerImplTest {

	@Mock
	private Dictionary<String, Object> componentContextProperties;
	@Mock
	private ComponentContext componentContext;
	@Mock
	private BundleContext bundleContext;
	@Mock
	private ResourceResolverFactory resourceResolverFactory;
	@Mock
	private ResourceResolver resourceResolver;
	@Mock(answer=Answers.RETURNS_DEEP_STUBS)
	private Session session;
	private List<ServiceRegistration> serviceRegistrations = new ArrayList<ServiceRegistration>();

	private SuperimposingManagerImpl underTest;

	private static final String ORIGINAL_PATH = "/root/path1";
	private static final String SUPERIMPOSED_PATH = "/root/path2";
	private static final String OBSERVATION_PATH = "/root";

	@SuppressWarnings("unchecked")
	@Before
	public void setUp() throws LoginException {
	when(componentContext.getBundleContext()).thenReturn(bundleContext);
	when(componentContext.getProperties()).thenReturn(componentContextProperties);
	when(componentContextProperties.get(SuperimposingManagerImpl.OBSERVATION_PATHS_PROPERTY)).thenReturn(new String[] { OBSERVATION_PATH });
	when(resourceResolverFactory.getAdministrativeResourceResolver(any(Map.class))).thenReturn(resourceResolver);
	when(resourceResolver.adaptTo(Session.class)).thenReturn(session);

	// collect a list of all service registrations to validate that they are all unregistered on shutdown
	when(bundleContext.registerService(anyString(), anyObject(), any(Dictionary.class))).thenAnswer(new Answer<ServiceRegistration>() {
	public ServiceRegistration answer(InvocationOnMock invocation) {
	final ServiceRegistration mockRegistration = mock(ServiceRegistration.class);
	serviceRegistrations.add(mockRegistration);
	doAnswer(new Answer() {
	public Object answer(InvocationOnMock invocation) {
	return serviceRegistrations.remove(mockRegistration);
	}
	}).when(mockRegistration).unregister();
	return mockRegistration;
	}
	});

	// simulate absolute path access to properties via session object
	try {
	when(session.itemExists(anyString())).thenAnswer(new Answer<Boolean>() {
	public Boolean answer(InvocationOnMock invocation) throws Throwable {
	final String absolutePath = (String)invocation.getArguments()[0];
	final String nodePath = ResourceUtil.getParent(absolutePath);
	final String propertyName = ResourceUtil.getName(absolutePath);
	Resource resource = resourceResolver.getResource(nodePath);
	if (resource!=null) {
	ValueMap props = resource.adaptTo(ValueMap.class);
	return props.containsKey(propertyName);
	}
	else {
	return false;
	}
	}
	});
	when(session.getProperty(anyString())).thenAnswer(new Answer<Property>() {
	public Property answer(InvocationOnMock invocation) throws Throwable {
	final String absolutePath = (String)invocation.getArguments()[0];
	final String nodePath = ResourceUtil.getParent(absolutePath);
	final String propertyName = ResourceUtil.getName(absolutePath);
	Resource resource = resourceResolver.getResource(nodePath);
	if (resource!=null) {
	ValueMap props = resource.adaptTo(ValueMap.class);
	Object value = props.get(propertyName);
	if (value==null) {
	throw new PathNotFoundException();
	}
	Property prop = mock(Property.class);
	when(prop.getName()).thenReturn(propertyName);
	if (value instanceof String) {
	when(prop.getString()).thenReturn((String)value);
	}
	else if (value instanceof Boolean) {
	when(prop.getBoolean()).thenReturn((Boolean)value);
	}
	return prop;
	}
	else {
	throw new PathNotFoundException();
	}
	}
	});
	}
	catch (RepositoryException ex) {
	throw new RuntimeException(ex);
	}
	}

	private void initialize(boolean enabled) throws InterruptedException, LoginException, RepositoryException {
	when(componentContextProperties.get(SuperimposingManagerImpl.ENABLED_PROPERTY)).thenReturn(enabled);

	underTest = new SuperimposingManagerImpl().withResourceResolverFactory(resourceResolverFactory);
	underTest.activate(componentContext);

	if (underTest.isEnabled()) {
	// verify observation registration
	verify(session.getWorkspace().getObservationManager()).addEventListener(any(EventListener.class), anyInt(), eq(OBSERVATION_PATH), anyBoolean(), any(String[].class), any(String[].class), anyBoolean());
	// wait until separate initialization thread has finished
	while (!underTest.initialization.isDone()) {
	Thread.sleep(10);
	}
	}
	}

	@After
	public void tearDown() throws RepositoryException {
	underTest.deactivate(componentContext);

	if (underTest.isEnabled()) {
	// verify observation and resource resolver are terminated correctly
	verify(session.getWorkspace().getObservationManager()).removeEventListener(any(EventListener.class));
	verify(resourceResolver).close();
	}

	// make sure all registrations are unregistered on shutdown
	for (ServiceRegistration registration : serviceRegistrations) {
	verify(registration, times(1)).unregister();
	}
	}

	private Resource prepareSuperimposingResource(String superimposedPath, String sourcePath, boolean registerParent, boolean overlayable) {
	Resource resource = mock(Resource.class);
	when(resource.getPath()).thenReturn(superimposedPath);
	ValueMap props = new ValueMapDecorator(new HashMap<String, Object>());
	props.put(PROP_SUPERIMPOSE_SOURCE_PATH, sourcePath);
	props.put(PROP_SUPERIMPOSE_REGISTER_PARENT, registerParent);
	props.put(PROP_SUPERIMPOSE_OVERLAYABLE, overlayable);
	when(resource.adaptTo(ValueMap.class)).thenReturn(props);
	when(resourceResolver.getResource(superimposedPath)).thenReturn(resource);
	return resource;
	}

	private void moveSuperimposedResource(Resource resource, String newPath) {
	String oldPath = resource.getPath();
	when(resource.getPath()).thenReturn(newPath);
	when(resourceResolver.getResource(oldPath)).thenReturn(null);
	when(resourceResolver.getResource(newPath)).thenReturn(resource);
	}

	@Test
	public void testDisabled() throws InterruptedException, LoginException, RepositoryException {
	// make sure that no exception is thrown when service is disabled on activate/deactivate
	initialize(false);

	verifyZeroInteractions(resourceResolverFactory);
	verifyZeroInteractions(bundleContext);
	}

	@SuppressWarnings("unchecked")
	@Test
	public void testFindAllSuperimposings() throws InterruptedException, LoginException, RepositoryException {
	// prepare a query that returns one existing superimposed resource
	when(componentContextProperties.get(SuperimposingManagerImpl.FINDALLQUERIES_PROPERTY)).thenReturn("syntax\|query");
	when(resourceResolver.findResources("query", "syntax")).then(new Answer<Iterator<Resource>>() {
	public Iterator<Resource> answer(InvocationOnMock invocation) {
	return Arrays.asList(new Resource[] {
	prepareSuperimposingResource(SUPERIMPOSED_PATH, ORIGINAL_PATH, false, false)
	}).iterator();
	}
	});
	initialize(true);

	// ensure the superimposed resource is detected and registered
	List<SuperimposingResourceProvider> providers = IteratorUtils.toList(underTest.getRegisteredProviders());
	assertEquals(1, providers.size());
	SuperimposingResourceProvider provider = providers.iterator().next();
	assertEquals(SUPERIMPOSED_PATH, provider.getRootPath());
	assertEquals(ORIGINAL_PATH, provider.getSourcePath());
	assertFalse(provider.isOverlayable());
	verify(bundleContext).registerService(anyString(), same(provider), any(Dictionary.class));
	}

	private EventIterator prepareNodeCreateEvent(Resource pResource) throws RepositoryException {
	String resourcePath = pResource.getPath();

	Event nodeEvent = mock(Event.class);
	when(nodeEvent.getType()).thenReturn(Event.NODE_ADDED);
	when(nodeEvent.getPath()).thenReturn(resourcePath);

	Event propertyEvent = mock(Event.class);
	when(propertyEvent.getType()).thenReturn(Event.PROPERTY_ADDED);
	when(propertyEvent.getPath()).thenReturn(resourcePath + "/" + SuperimposingResourceProvider.PROP_SUPERIMPOSE_SOURCE_PATH);

	EventIterator eventIterator = mock(EventIterator.class);
	when(eventIterator.hasNext()).thenReturn(true, true, false);
	when(eventIterator.nextEvent()).thenReturn(nodeEvent, propertyEvent);
	return eventIterator;
	}

	private EventIterator prepareNodeChangeEvent(Resource pResource) throws RepositoryException {
	String resourcePath = pResource.getPath();

	Event propertyEvent = mock(Event.class);
	when(propertyEvent.getType()).thenReturn(Event.PROPERTY_CHANGED);
	when(propertyEvent.getPath()).thenReturn(resourcePath + "/" + SuperimposingResourceProvider.PROP_SUPERIMPOSE_SOURCE_PATH);

	EventIterator eventIterator = mock(EventIterator.class);
	when(eventIterator.hasNext()).thenReturn(true, false);
	when(eventIterator.nextEvent()).thenReturn(propertyEvent);
	return eventIterator;
	}

	private EventIterator prepareNodeRemoveEvent(Resource pResource) throws RepositoryException {
	String resourcePath = pResource.getPath();

	Event nodeEvent = mock(Event.class);
	when(nodeEvent.getType()).thenReturn(Event.NODE_REMOVED);
	when(nodeEvent.getPath()).thenReturn(resourcePath);

	EventIterator eventIterator = mock(EventIterator.class);
	when(eventIterator.hasNext()).thenReturn(true, false);
	when(eventIterator.nextEvent()).thenReturn(nodeEvent);
	return eventIterator;
	}

	private EventIterator prepareNodeMoveEvent(Resource pResource, String pOldPath) throws RepositoryException {
	String resourcePath = pResource.getPath();

	Event nodeRemoveEvent = mock(Event.class);
	when(nodeRemoveEvent.getType()).thenReturn(Event.NODE_REMOVED);
	when(nodeRemoveEvent.getPath()).thenReturn(pOldPath);

	Event nodeCreateEvent = mock(Event.class);
	when(nodeCreateEvent.getType()).thenReturn(Event.NODE_ADDED);
	when(nodeCreateEvent.getPath()).thenReturn(resourcePath);

	EventIterator eventIterator = mock(EventIterator.class);
	when(eventIterator.hasNext()).thenReturn(true, true, false);
	when(eventIterator.nextEvent()).thenReturn(nodeRemoveEvent, nodeCreateEvent);
	return eventIterator;
	}

	@SuppressWarnings("unchecked")
	@Test
	public void testSuperimposedResourceCreateUpdateRemove() throws InterruptedException, LoginException, RepositoryException {
	initialize(true);

	// simulate node create event
	Resource superimposedResource = prepareSuperimposingResource(SUPERIMPOSED_PATH, ORIGINAL_PATH, false, false);
	underTest.onEvent(prepareNodeCreateEvent(superimposedResource));

	// ensure the superimposed resource is detected and registered
	List<SuperimposingResourceProvider> providers = IteratorUtils.toList(underTest.getRegisteredProviders());
	assertEquals(1, providers.size());
	SuperimposingResourceProvider provider = providers.iterator().next();
	assertEquals(SUPERIMPOSED_PATH, provider.getRootPath());
	assertEquals(ORIGINAL_PATH, provider.getSourcePath());
	assertFalse(provider.isOverlayable());
	verify(bundleContext).registerService(anyString(), same(provider), any(Dictionary.class));

	// simulate a change in the original path
	superimposedResource.adaptTo(ValueMap.class).put(PROP_SUPERIMPOSE_SOURCE_PATH, "/other/path");
	underTest.onEvent(prepareNodeChangeEvent(superimposedResource));

	// ensure the superimposed resource update is detected and a new provider instance is registered
	providers = IteratorUtils.toList(underTest.getRegisteredProviders());
	assertEquals(1, providers.size());
	SuperimposingResourceProvider provider2 = providers.iterator().next();
	assertEquals(SUPERIMPOSED_PATH, provider2.getRootPath());
	assertEquals("/other/path", provider2.getSourcePath());
	assertFalse(provider2.isOverlayable());
	verify(bundleContext).registerService(anyString(), same(provider2), any(Dictionary.class));

	// simulate node removal
	underTest.onEvent(prepareNodeRemoveEvent(superimposedResource));

	// ensure provider is removed
	providers = IteratorUtils.toList(underTest.getRegisteredProviders());
	assertEquals(0, providers.size());
	}

	@SuppressWarnings("unchecked")
	@Test
	public void testSuperimposedResourceCreateMove() throws InterruptedException, LoginException, RepositoryException {
	when(componentContextProperties.get(SuperimposingManagerImpl.FINDALLQUERIES_PROPERTY)).thenReturn("syntax\|query");
	initialize(true);

	// simulate node create event
	final Resource superimposedResource = prepareSuperimposingResource(SUPERIMPOSED_PATH, ORIGINAL_PATH, false, false);
	underTest.onEvent(prepareNodeCreateEvent(superimposedResource));

	// simulate a node move event
	String oldPath = superimposedResource.getPath();
	moveSuperimposedResource(superimposedResource, "/new/path");

	// prepare a query that returns the moved superimposed resource
	when(resourceResolver.findResources("query", "syntax")).then(new Answer<Iterator<Resource>>() {
	public Iterator<Resource> answer(InvocationOnMock invocation) {
	return Arrays.asList(new Resource[] {
	superimposedResource
	}).iterator();
	}
	});

	underTest.onEvent(prepareNodeMoveEvent(superimposedResource, oldPath));

	// ensure the superimposed resource update is detected and a new provider instance is registered
	List<SuperimposingResourceProvider> providers = IteratorUtils.toList(underTest.getRegisteredProviders());
	assertEquals(1, providers.size());
	SuperimposingResourceProvider provider = providers.iterator().next();
	assertEquals("/new/path", provider.getRootPath());
	assertEquals(ORIGINAL_PATH, provider.getSourcePath());
	assertFalse(provider.isOverlayable());
	verify(bundleContext).registerService(anyString(), same(provider), any(Dictionary.class));
	}

	}