You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sling.apache.org by ro...@apache.org on 2017/11/07 10:00:41 UTC
[sling-org-apache-sling-resourceresolver] 12/14: SLING-2725
Coverage at 65%,
some areas not covered marked with TODOs in MockedResourceResolverImplTest.
This is an automated email from the ASF dual-hosted git repository.
rombert pushed a commit to annotated tag org.apache.sling.resourceresolver-1.0.4
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-resourceresolver.git
commit 4d052c99a56d52ce0fc7ff4213e04fa524b992ce
Author: Ian Boston <ie...@apache.org>
AuthorDate: Mon Feb 11 05:54:40 2013 +0000
SLING-2725 Coverage at 65%, some areas not covered marked with TODOs in MockedResourceResolverImplTest.
git-svn-id: https://svn.apache.org/repos/asf/sling/trunk/bundles/resourceresolver@1444661 13f79535-47bb-0310-9956-ffa450edef68
---
.../impl/MockedResourceResolverImplTest.java | 275 ++++++++++++++++++---
1 file changed, 236 insertions(+), 39 deletions(-)
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/MockedResourceResolverImplTest.java b/src/test/java/org/apache/sling/resourceresolver/impl/MockedResourceResolverImplTest.java
index 9356901..52ad4a1 100644
--- a/src/test/java/org/apache/sling/resourceresolver/impl/MockedResourceResolverImplTest.java
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/MockedResourceResolverImplTest.java
@@ -25,14 +25,16 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+
import org.apache.sling.api.resource.LoginException;
+import org.apache.sling.api.resource.QueriableResourceProvider;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceMetadata;
import org.apache.sling.api.resource.ResourceProvider;
import org.apache.sling.api.resource.ResourceProviderFactory;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
-import org.apache.sling.api.resource.ResourceUtil;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -41,24 +43,25 @@ import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.event.EventAdmin;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* This tests the ResourceResolver using mocks. The Unit test is in addition to
* ResourceResolverImplTest which covers API conformance more than it covers all
* code paths.
*/
+// TODO: Configure mapping to react correctly.
+// TODO: test external redirect.
+// TODO: Map to URI
+// TODO: Statresource
+// TODO: relative resource.
+// TODO: SLING-864, path with . in it.
+// TODO: search path eg text/html which will search on /apps/text/html and then /libs/text/html
public class MockedResourceResolverImplTest {
- private static final Logger LOGGER = LoggerFactory.getLogger(MockedResourceResolverImplTest.class);
-
private static final List<Resource> EMPTY_RESOURCE_LIST = new ArrayList<Resource>();
private ResourceResolverFactoryActivator activator;
@@ -101,6 +104,7 @@ public class MockedResourceResolverImplTest {
MockitoAnnotations.initMocks(this);
}
+ @SuppressWarnings("unchecked")
@Before
public void before() throws LoginException {
activator = new ResourceResolverFactoryActivator();
@@ -116,7 +120,7 @@ public class MockedResourceResolverImplTest {
new String[] { "/single" }));
// setup mapping resources at /etc/map to exercise vanity etc.
- Resource etcMapResource = buildResource("/etc/map", buildMapIterable());
+ Resource etcMapResource = buildResource("/etc/map", buildChildResources("/etc/map"));
Mockito.when(mappingResourceProvider.getResource(Mockito.any(ResourceResolver.class), Mockito.eq("/etc/map"))).thenReturn(etcMapResource);
activator.bindResourceProvider(mappingResourceProvider,
@@ -148,6 +152,7 @@ public class MockedResourceResolverImplTest {
// extract any services that were registered into a map.
ArgumentCaptor<String> classesCaptor = ArgumentCaptor.forClass(String.class);
ArgumentCaptor<Object> serviceCaptor = ArgumentCaptor.forClass(Object.class);
+ @SuppressWarnings("rawtypes")
ArgumentCaptor<Dictionary> propertiesCaptor = ArgumentCaptor.forClass(Dictionary.class);
Mockito.verify(bundleContext, Mockito.atLeastOnce()).registerService(
classesCaptor.capture(), serviceCaptor.capture(),
@@ -155,6 +160,7 @@ public class MockedResourceResolverImplTest {
int si = 0;
List<Object> serviceList = serviceCaptor.getAllValues();
+ @SuppressWarnings({ "unused", "rawtypes" })
List<Dictionary> servicePropertiesList = propertiesCaptor.getAllValues();
for (String serviceName : classesCaptor.getAllValues()) {
services.put(serviceName, serviceList.get(si));
@@ -168,30 +174,82 @@ public class MockedResourceResolverImplTest {
resourceResolverFactory = (ResourceResolverFactoryImpl) rrf;
}
- private Iterable<Resource> buildMapIterable() {
+ @After
+ public void after() {
+ activator.unbindResourceProvider(resourceProvider,
+ buildResourceProviderProperties("org.apache.sling.resourceresolver.impl.DummyTestProvider",
+ 10L,
+ new String[] { "/single" }));
+ activator.unbindResourceProvider(mappingResourceProvider,
+ buildResourceProviderProperties("org.apache.sling.resourceresolver.impl.MapProvider",
+ 11L,
+ new String[] { "/etc" }));
+ activator.bindResourceProviderFactory(resourceProviderFactory,
+ buildResourceProviderProperties("org.apache.sling.resourceresolver.impl.DummyTestProviderFactory",
+ 12L,
+ new String[] { "/factory" } ));
+
+ }
+
+ /**
+ * build child resources as an iterable of resources.
+ * @param parent
+ * @return
+ */
+ private Iterable<Resource> buildChildResources(String parent) {
List<Resource> mappingResources = new ArrayList<Resource>();
- mappingResources.add(buildResource("/etc/map/m1", EMPTY_RESOURCE_LIST));
- mappingResources.add(buildResource("/etc/map/m2", EMPTY_RESOURCE_LIST));
- mappingResources.add(buildResource("/etc/map/m3", EMPTY_RESOURCE_LIST));
+ for ( int i = 0; i < 5; i++ ) {
+ mappingResources.add(buildResource(parent+"/m"+i, EMPTY_RESOURCE_LIST));
+ }
return mappingResources;
}
-
+ /**
+ * Build a resource based on path and children.
+ * @param fullpath
+ * @param children
+ * @return
+ */
private Resource buildResource(String fullpath, Iterable<Resource> children) {
+ return buildResource(fullpath, children, null);
+ }
+
+ /**
+ * Build a resource with path, children and resource resolver.
+ * @param fullpath
+ * @param children
+ * @param resourceResolver
+ * @return
+ */
+ private Resource buildResource(String fullpath, Iterable<Resource> children, ResourceResolver resourceResolver) {
Resource resource = Mockito.mock(Resource.class);
Mockito.when(resource.getName()).thenReturn(getName(fullpath));
Mockito.when(resource.getPath()).thenReturn(fullpath);
ResourceMetadata resourceMetadata = new ResourceMetadata();
Mockito.when(resource.getResourceMetadata()).thenReturn(resourceMetadata);
Mockito.when(resource.listChildren()).thenReturn(children.iterator());
+ Mockito.when(resource.getResourceResolver()).thenReturn(resourceResolver);
return resource;
}
+ /**
+ * extract the name from a path.
+ * @param fullpath
+ * @return
+ */
private String getName(String fullpath) {
int n = fullpath.lastIndexOf("/");
- return fullpath.substring(n);
+ return fullpath.substring(n+1);
}
+
+ /**
+ * Build properties for a resource provider.
+ * @param servicePID
+ * @param serviceID
+ * @param roots
+ * @return
+ */
private Map<String, Object> buildResourceProviderProperties(String servicePID, long serviceID, String[] roots) {
Map<String, Object> resourceProviderProperties = new HashMap<String, Object>();
resourceProviderProperties.put(Constants.SERVICE_PID, servicePID);
@@ -199,10 +257,18 @@ public class MockedResourceResolverImplTest {
resourceProviderProperties.put(Constants.SERVICE_VENDOR, "Apache");
resourceProviderProperties.put(Constants.SERVICE_DESCRIPTION,
"Dummy Provider");
+ resourceProviderProperties.put(QueriableResourceProvider.LANGUAGES,
+ new String[] { "lang1"} );
+
+
resourceProviderProperties.put(ResourceProvider.ROOTS, roots);
return resourceProviderProperties;
}
+ /**
+ * build a properties for a resource resolver bundle.
+ * @return
+ */
private Dictionary<String, Object> buildBundleProperties() {
Dictionary<String, Object> properties = new Hashtable<String, Object>();
properties.put("resource.resolver.virtual", new String[] { "/:/" });
@@ -222,23 +288,30 @@ public class MockedResourceResolverImplTest {
return properties;
}
- @After
- public void after() {
- activator.unbindResourceProvider(resourceProvider,
- buildResourceProviderProperties("org.apache.sling.resourceresolver.impl.DummyTestProvider",
- 10L,
- new String[] { "/single" }));
- activator.unbindResourceProvider(mappingResourceProvider,
- buildResourceProviderProperties("org.apache.sling.resourceresolver.impl.MapProvider",
- 11L,
- new String[] { "/etc" }));
- activator.bindResourceProviderFactory(resourceProviderFactory,
- buildResourceProviderProperties("org.apache.sling.resourceresolver.impl.DummyTestProviderFactory",
- 12L,
- new String[] { "/factory" } ));
-
+ /**
+ * Register a resource for testing purposes at a path, with a provider, with children.
+ * @param resourceResolver
+ * @param targetResourceProvider
+ * @param path
+ * @param children
+ * @return
+ */
+ private Resource registerTestResource(ResourceResolver resourceResolver, ResourceProvider targetResourceProvider, String path, Iterable<Resource> children) {
+ Resource resource = buildResource(path, children, resourceResolver);
+ Mockito.when(
+ targetResourceProvider.getResource(
+ Mockito.any(ResourceResolver.class),
+ Mockito.eq(path))).thenReturn(resource);
+ Mockito.when(targetResourceProvider.listChildren(resource)).thenReturn(children.iterator());
+ return resource;
}
+
+
+ /**
+ * Test getting a resolver.
+ * @throws LoginException
+ */
@Test
public void testGetResolver() throws LoginException {
ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
@@ -248,6 +321,26 @@ public class MockedResourceResolverImplTest {
Assert.assertNotNull(resourceResolver);
}
+ /**
+ * Misceleneous coverage.
+ * @throws LoginException
+ */
+ @Test
+ public void testResolverMisc() throws LoginException {
+ ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
+ try {
+ resourceResolver.getAttribute(null);
+ Assert.fail("Should have thrown a NPE");
+ } catch ( NullPointerException e) {
+ // this is expected.
+ }
+ Assert.assertArrayEquals(new String[]{"/apps/","/libs/"}, resourceResolver.getSearchPath());
+ }
+
+ /**
+ * Test various administrative resource resolvers.
+ * @throws LoginException
+ */
@Test
public void testGetAuthenticatedResolve() throws LoginException {
ResourceResolver resourceResolver = resourceResolverFactory.getAdministrativeResourceResolver(null);
@@ -258,28 +351,132 @@ public class MockedResourceResolverImplTest {
Assert.assertNotNull(resourceResolver);
}
+ /**
+ * Test getResource for a resource provided by a resource provider.
+ * @throws LoginException
+ */
@Test
public void testGetResource() throws LoginException {
ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
Assert.assertNotNull(resourceResolver);
- Resource singleResource = buildResource("/sling/test", EMPTY_RESOURCE_LIST);
- Mockito.when(
- resourceProvider.getResource(Mockito.any(ResourceResolver.class),
- Mockito.eq("/single/test"))).thenReturn(singleResource);
+ Resource singleResource = registerTestResource(resourceResolver, resourceProvider, "/single/test", EMPTY_RESOURCE_LIST);
Resource resource = resourceResolver.getResource("/single/test");
Assert.assertEquals(singleResource, resource);
}
+ /**
+ * Test getResource for a resource provided by a factory provider.
+ * @throws LoginException
+ */
@Test
public void testGetFactoryResource() throws LoginException {
ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
Assert.assertNotNull(resourceResolver);
- Resource factoryResource = buildResource("/factory/test", EMPTY_RESOURCE_LIST);
- Mockito.when(
- factoryResourceProvider.getResource(
- Mockito.any(ResourceResolver.class),
- Mockito.eq("/factory/test"))).thenReturn(factoryResource);
+
+ Resource factoryResource = registerTestResource(resourceResolver, factoryResourceProvider, "/factory/test", EMPTY_RESOURCE_LIST);
Resource resource = resourceResolver.getResource("/factory/test");
- Assert.assertEquals(factoryResource,resource);
+ Assert.assertEquals(factoryResource, resource);
}
+
+ /**
+ * Basic test of mapping functionality, at the moment needs more
+ * configuration in the virtual /etc/map.
+ *
+ * @throws LoginException
+ */
+ @Test
+ public void testMapping() throws LoginException {
+ ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
+ registerTestResource(resourceResolver, factoryResourceProvider, "/factory/test", EMPTY_RESOURCE_LIST);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(request.getScheme()).thenReturn("http");
+ Mockito.when(request.getServerPort()).thenReturn(8080);
+ Mockito.when(request.getServerName()).thenReturn("localhost");
+ String path = resourceResolver.map(request,"/factory/test?q=123123");
+ Assert.assertEquals("/factory/test?q=123123", path);
+ path = resourceResolver.map(request,"/factory/test");
+ Assert.assertEquals("/factory/test", path);
+
+ // test path mapping without a request.
+ path = resourceResolver.map("/factory/test");
+ Assert.assertEquals("/factory/test", path);
+
+
+ }
+
+
+ /**
+ * Tests list children via the resource (NB, this doesn't really test the
+ * resource resolver at all, but validates this unit test.)
+ *
+ * @throws LoginException
+ */
+ @Test
+ public void testListChildren() throws LoginException {
+ ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
+ registerTestResource(resourceResolver, resourceProvider, "/single/test/withchildren", buildChildResources("/single/test/withchildren"));
+
+
+ Resource resource = resourceResolver.getResource("/single/test/withchildren");
+ Assert.assertNotNull(resource);
+
+ // test via the resource list children itself, this really just tests this test case.
+ Iterator<Resource> resourceIterator = resource.listChildren();
+ Assert.assertNotNull(resourceResolver);
+ int i = 0;
+ while(resourceIterator.hasNext()) {
+ Assert.assertEquals("m"+i, resourceIterator.next().getName());
+ i++;
+ }
+ Assert.assertEquals(5, i);
+ }
+
+ /**
+ * Test listing children via the resource resolver listChildren call.
+ * @throws LoginException
+ */
+ @Test
+ public void testResourceResolverListChildren() throws LoginException {
+ ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
+ registerTestResource(resourceResolver, resourceProvider, "/single/test/withchildren", buildChildResources("/single/test/withchildren"));
+
+
+ Resource resource = resourceResolver.getResource("/single/test/withchildren");
+ Assert.assertNotNull(resource);
+
+ // test via the resource list children itself, this really just tests this test case.
+ Iterator<Resource> resourceIterator = resourceResolver.listChildren(resource);
+ Assert.assertNotNull(resourceResolver);
+ int i = 0;
+ while(resourceIterator.hasNext()) {
+ Assert.assertEquals("m"+i, resourceIterator.next().getName());
+ i++;
+ }
+ Assert.assertEquals(5,i);
+ }
+
+ /**
+ * Tests listing children via the resource resolver getChildren call.
+ * @throws LoginException
+ */
+ @Test
+ public void testResourceResolverGetChildren() throws LoginException {
+ ResourceResolver resourceResolver = resourceResolverFactory.getResourceResolver(null);
+ registerTestResource(resourceResolver, resourceProvider, "/single/test/withchildren", buildChildResources("/single/test/withchildren"));
+
+
+ Resource resource = resourceResolver.getResource("/single/test/withchildren");
+ Assert.assertNotNull(resource);
+
+ // test via the resource list children itself, this really just tests this test case.
+ Iterable<Resource> resourceIterator = resourceResolver.getChildren(resource);
+ Assert.assertNotNull(resourceResolver);
+ int i = 0;
+ for(Resource r : resourceIterator) {
+ Assert.assertEquals("m"+i, r.getName());
+ i++;
+ }
+ Assert.assertEquals(5,i);
+ }
+
}
--
To stop receiving notification emails like this one, please contact
"commits@sling.apache.org" <co...@sling.apache.org>.