| /* |
| * 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.junit.Assert.*; |
| import static org.mockito.Mockito.*; |
| |
| import java.util.Arrays; |
| import java.util.Dictionary; |
| import java.util.Iterator; |
| |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Session; |
| |
| import org.apache.sling.api.resource.Resource; |
| import org.apache.sling.api.resource.ResourceMetadata; |
| import org.apache.sling.api.resource.ResourceResolver; |
| import org.apache.sling.api.resource.ResourceWrapper; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| 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; |
| |
| @RunWith(MockitoJUnitRunner.class) |
| public class SuperimposingResourceProviderImplTest { |
| |
| private SuperimposingResourceProviderImpl underTest; |
| private SuperimposingResourceProviderImpl underTestOverlay; |
| |
| @Mock |
| private BundleContext bundleContext; |
| @Mock |
| private ServiceRegistration serviceRegistration; |
| @Mock |
| private ServiceRegistration serviceRegistrationOverlay; |
| @Mock |
| private ResourceResolver resourceResolver; |
| @Mock |
| private Session session; |
| @Mock |
| private Resource originalRootResource; |
| @Mock |
| private Resource originalSubResource; |
| |
| private static final String ORIGINAL_PATH = "/root/path1"; |
| private static final String SUPERIMPOSED_PATH = "/root/path2"; |
| private static final String RESOURCE_TYPE = "/resourceType1"; |
| |
| @Before |
| public void setUp() { |
| // setup a superimposing resource provider without overlay |
| underTest = new SuperimposingResourceProviderImpl(SUPERIMPOSED_PATH, ORIGINAL_PATH, false); |
| when(bundleContext.registerService(anyString(), eq(underTest), any(Dictionary.class))).thenReturn(serviceRegistration); |
| underTest.registerService(bundleContext); |
| |
| // and one with overlay |
| underTestOverlay = new SuperimposingResourceProviderImpl(SUPERIMPOSED_PATH, ORIGINAL_PATH, true); |
| when(bundleContext.registerService(anyString(), eq(underTestOverlay), any(Dictionary.class))).thenReturn(serviceRegistrationOverlay); |
| underTestOverlay.registerService(bundleContext); |
| |
| // prepare test resources |
| prepareOriginalResource(originalRootResource, ORIGINAL_PATH); |
| prepareOriginalResource(originalSubResource, ORIGINAL_PATH + "/sub1"); |
| when(resourceResolver.listChildren(originalRootResource)).thenAnswer(new Answer<Iterator<Resource>>() { |
| public Iterator<Resource> answer(InvocationOnMock invocation) { |
| return Arrays.asList(new Resource[] { originalSubResource }).iterator(); |
| } |
| }); |
| } |
| |
| private void prepareOriginalResource(Resource mockResource, String path) { |
| // prepare resource |
| when(mockResource.getPath()).thenReturn(path); |
| when(mockResource.getResourceType()).thenReturn(RESOURCE_TYPE); |
| when(mockResource.getResourceSuperType()).thenReturn(null); |
| ResourceMetadata resourceMetadata = new ResourceMetadata(); |
| resourceMetadata.setResolutionPath(path); |
| when(mockResource.getResourceMetadata()).thenReturn(resourceMetadata); |
| when(mockResource.getResourceResolver()).thenReturn(resourceResolver); |
| |
| // mount in resource tree |
| when(resourceResolver.getResource(path)).thenReturn(mockResource); |
| } |
| |
| @After |
| public void tearDown() { |
| underTest.unregisterService(); |
| verify(serviceRegistration).unregister(); |
| |
| underTestOverlay.unregisterService(); |
| verify(serviceRegistrationOverlay).unregister(); |
| } |
| |
| @Test |
| public void testGetter() { |
| assertEquals(SUPERIMPOSED_PATH, underTest.getRootPath()); |
| assertEquals(ORIGINAL_PATH, underTest.getSourcePath()); |
| assertFalse(underTest.isOverlayable()); |
| } |
| |
| @Test |
| public void testGetterOverlay() { |
| assertEquals(SUPERIMPOSED_PATH, underTestOverlay.getRootPath()); |
| assertEquals(ORIGINAL_PATH, underTestOverlay.getSourcePath()); |
| assertTrue(underTestOverlay.isOverlayable()); |
| } |
| |
| @Test |
| public void testEquals() { |
| assertTrue(underTest.equals(underTest)); |
| assertFalse(underTest.equals(underTestOverlay)); |
| assertTrue(underTestOverlay.equals(underTestOverlay)); |
| assertFalse(underTest.equals(underTestOverlay)); |
| } |
| |
| @Test |
| public void testGetMappedRootResource() { |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH); |
| assertTrue(resource instanceof SuperimposingResource); |
| assertEquals(SUPERIMPOSED_PATH, resource.getPath()); |
| |
| resource = underTestOverlay.getResource(resourceResolver, SUPERIMPOSED_PATH); |
| assertTrue(resource instanceof SuperimposingResource); |
| assertEquals(SUPERIMPOSED_PATH, resource.getPath()); |
| } |
| |
| @Test |
| public void testGetMappedRootResourceWithOverlay() throws RepositoryException { |
| when(resourceResolver.adaptTo(Session.class)).thenReturn(session); |
| when(session.itemExists(SUPERIMPOSED_PATH)).thenReturn(true); |
| |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH); |
| assertTrue(resource instanceof SuperimposingResource); |
| assertEquals(SUPERIMPOSED_PATH, resource.getPath()); |
| |
| // root path cannot be overlayed |
| resource = underTestOverlay.getResource(resourceResolver, SUPERIMPOSED_PATH); |
| assertTrue(resource instanceof SuperimposingResource); |
| assertEquals(SUPERIMPOSED_PATH, resource.getPath()); |
| } |
| |
| @Test |
| public void testGetMappedSubResource() { |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub1"); |
| assertTrue(resource instanceof SuperimposingResource); |
| assertEquals(SUPERIMPOSED_PATH + "/sub1", resource.getPath()); |
| |
| resource = underTestOverlay.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub1"); |
| assertTrue(resource instanceof SuperimposingResource); |
| assertEquals(SUPERIMPOSED_PATH + "/sub1", resource.getPath()); |
| } |
| |
| @Test |
| public void testGetMappedSubResourceWithOverlay() throws RepositoryException { |
| when(resourceResolver.adaptTo(Session.class)).thenReturn(session); |
| when(session.itemExists(SUPERIMPOSED_PATH + "/sub1")).thenReturn(true); |
| |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub1"); |
| assertTrue(resource instanceof SuperimposingResource); |
| assertEquals(SUPERIMPOSED_PATH + "/sub1", resource.getPath()); |
| |
| // overlay item exists, allow underlying resource provider to step in |
| resource = underTestOverlay.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub1"); |
| assertNull(resource); |
| } |
| |
| @Test |
| public void testGetMappedNonExistingResource() { |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub2"); |
| assertNull(resource); |
| |
| resource = underTestOverlay.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub2"); |
| assertNull(resource); |
| } |
| |
| @Test |
| public void testGetMappedNonExistingResourceWithOverlay() throws RepositoryException { |
| when(resourceResolver.adaptTo(Session.class)).thenReturn(session); |
| when(session.itemExists(SUPERIMPOSED_PATH + "/sub2")).thenReturn(true); |
| |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub2"); |
| assertNull(resource); |
| |
| resource = underTestOverlay.getResource(resourceResolver, SUPERIMPOSED_PATH + "/sub2"); |
| assertNull(resource); |
| } |
| |
| @Test |
| public void testGetMappedResourceRootInvalidPath() { |
| Resource resource = underTest.getResource(resourceResolver, "/invalid/path"); |
| assertNull(resource); |
| |
| resource = underTestOverlay.getResource(resourceResolver, "/invalid/path"); |
| assertNull(resource); |
| } |
| |
| @Test |
| public void testListChildren() { |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH); |
| Iterator<Resource> iterator = underTest.listChildren(resource); |
| assertTrue(iterator.hasNext()); |
| assertEquals(SUPERIMPOSED_PATH + "/sub1", iterator.next().getPath()); |
| } |
| |
| @Test |
| public void testListChildrenWithResourceWrapper() { |
| Resource resource = underTest.getResource(resourceResolver, SUPERIMPOSED_PATH); |
| Iterator<Resource> iterator = underTest.listChildren(new ResourceWrapper(resource)); |
| assertTrue(iterator.hasNext()); |
| assertEquals(SUPERIMPOSED_PATH + "/sub1", iterator.next().getPath()); |
| } |
| |
| @Test |
| public void testListChildrenNonSuperimposingResource() { |
| Iterator<Resource> iterator = underTest.listChildren(mock(Resource.class)); |
| assertNull(iterator); |
| } |
| |
| } |