SuperimposingResourceProviderImplTest.java

/*
 * 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);
    }

}