You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sling.apache.org by cz...@apache.org on 2021/04/27 16:55:14 UTC

[sling-org-apache-sling-resourceresolver] branch master updated: SLING-10335 : Wrong resource returned if overlap with mounted provider

This is an automated email from the ASF dual-hosted git repository.

cziegeler pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-resourceresolver.git


The following commit(s) were added to refs/heads/master by this push:
     new 79bce4d  SLING-10335 : Wrong resource returned if overlap with mounted provider
79bce4d is described below

commit 79bce4d31c5b2cc91fa517a19c9d36c3cea7de2c
Author: Carsten Ziegeler <cz...@apache.org>
AuthorDate: Tue Apr 27 18:55:05 2021 +0200

    SLING-10335 : Wrong resource returned if overlap with mounted provider
---
 .gitignore                                         |  1 +
 .../impl/helper/ResourceResolverControl.java       | 10 +++++----
 .../impl/helper/ResourceResolverControlTest.java   | 26 +++++++++++++++++-----
 3 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/.gitignore b/.gitignore
index 5b783ed..38f5ca4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,4 +14,5 @@ maven-eclipse.xml
 .vlt
 .DS_Store
 jcr.log
+.vscode
 atlassian-ide-plugin.xml
diff --git a/src/main/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControl.java b/src/main/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControl.java
index d15ea3c..356d492 100644
--- a/src/main/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControl.java
+++ b/src/main/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControl.java
@@ -272,13 +272,10 @@ public class ResourceResolverControl {
         if ( provider != null ) {
             realChildren = provider.listChildren(parent);
         }
-
+ 
         final Set<String> visitedNames = new HashSet<>();
 
         IteratorChain chain = new IteratorChain();
-        if ( realChildren != null ) {
-            chain.addIterator(realChildren);
-        }
 
         // synthetic and providers are done in one loop
         final Node<ResourceProviderHandler> node = getResourceProviderStorage().getTree().getNode(parent.getPath());
@@ -318,9 +315,14 @@ public class ResourceResolverControl {
             if ( !providerList.isEmpty() ) {
                 chain.addIterator(providerList.iterator());
             }
+            if ( realChildren != null ) {
+                chain.addIterator(realChildren);
+            }
             if ( !syntheticList.isEmpty() ) {
                 chain.addIterator(syntheticList.iterator());
             }
+        } else if ( realChildren != null ) {
+            chain.addIterator(realChildren);
         }
         if ( chain.size() == 0 ) {
             return Collections.EMPTY_LIST.iterator();
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControlTest.java b/src/test/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControlTest.java
index 93957a2..898dc57 100644
--- a/src/test/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControlTest.java
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/helper/ResourceResolverControlTest.java
@@ -27,6 +27,7 @@ import static org.hamcrest.Matchers.nullValue;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -97,6 +98,9 @@ public class ResourceResolverControlTest {
     private ResourceProvider<Object> rootProvider;
     private Resource subProviderResource;
     private Resource somethingResource;
+    private Resource someRootResource;
+    private Resource somePathRootResource;
+    private Resource somePathResource;
     private ResourceResolverContext context;
 
     @Before
@@ -110,6 +114,11 @@ public class ResourceResolverControlTest {
         subProvider = Mockito.mock(ResourceProvider.class);
         ResourceProviderInfo info = fixture.registerResourceProvider(subProvider, "/some/path", AuthType.required);
         ResourceProviderHandler handler = new ResourceProviderHandler(bc, info);
+        // second sub provider
+        ResourceProvider<?> subProvider2 = Mockito.mock(ResourceProvider.class);
+        ResourceProviderInfo info2 = fixture.registerResourceProvider(subProvider2, "/foo/path", AuthType.required);
+        ResourceProviderHandler handler2 = new ResourceProviderHandler(bc, info2);
+
         when(subProvider.getQueryLanguageProvider()).thenReturn(new SimpleQueryLanguageProvider(QL_MOCK, QL_ANOTHER_MOCK) {
             @Override
             public Iterator<ValueMap> queryResources(ResolveContext<Object> ctx, String query, String language) {
@@ -134,6 +143,7 @@ public class ResourceResolverControlTest {
             }
         });
         handler.activate();
+        handler2.activate();
 
         rootProvider = mock(ResourceProvider.class);
         ResourceProviderInfo rootInfo = fixture.registerResourceProvider(rootProvider, "/", AuthType.required);
@@ -145,15 +155,20 @@ public class ResourceResolverControlTest {
         Resource root = configureResourceAt(rootProvider, "/");
         somethingResource = configureResourceAt(rootProvider, "/something");
         subProviderResource = configureResourceAt(subProvider, "/some/path/object");
+        someRootResource = configureResourceAt(rootProvider, "/some");
+        somePathResource = configureResourceAt(subProvider, "/some/path");
+        somePathRootResource = configureResourceAt(rootProvider, "/some/path");
 
         // configure query at '/'
-        when(rootProvider.listChildren((ResolveContext<Object>) Mockito.anyObject(), Mockito.eq(root))).thenReturn(Collections.singleton(somethingResource).iterator());
+        when(rootProvider.listChildren((ResolveContext<Object>) Mockito.anyObject(), Mockito.eq(root))).thenReturn(Arrays.asList(somethingResource, someRootResource).iterator());
+        when(rootProvider.listChildren((ResolveContext<Object>) Mockito.anyObject(), Mockito.eq(someRootResource))).thenReturn(Arrays.asList(somePathRootResource).iterator());
+        when(rootProvider.getResource((ResolveContext<Object>) Mockito.anyObject(), Mockito.eq("/some/path"), Mockito.anyObject(), Mockito.anyObject())).thenReturn(somePathResource);
 
         ResourceResolver rr = mock(ResourceResolver.class);
         ResourceAccessSecurityTracker securityTracker = Mockito.mock(ResourceAccessSecurityTracker.class);
         authInfo = getAuthInfo();
 
-        handlers = Arrays.asList(rootHandler, handler);
+        handlers = Arrays.asList(rootHandler, handler, handler2);
         final ResourceProviderStorage storage = new ResourceProviderStorage(handlers);
 
         crp = new ResourceResolverControl(false, authInfo, new ResourceProviderStorageProvider() {
@@ -233,7 +248,7 @@ public class ResourceResolverControlTest {
     @Test
     public void getResource_synthetic() {
 
-        Resource resource = crp.getResource(context, "/some", null, null, false);
+        Resource resource = crp.getResource(context, "/foo", null, null, false);
 
         assertTrue("Not a syntethic resource : " + resource, ResourceUtil.isSyntheticResource(resource));
     }
@@ -314,9 +329,10 @@ public class ResourceResolverControlTest {
             all.put(child.getPath(), child);
         }
 
-        assertThat(all.entrySet(), Matchers.hasSize(2));
+        assertThat(all.entrySet(), Matchers.hasSize(3));
         assertThat("Resource at /something", all.get("/something"), not(nullValue()));
         assertThat("Resource at /some", all.get("/some"), not(nullValue()));
+        assertThat("Resource at /foo", all.get("/foo"), not(nullValue()));
     }
 
     /**
@@ -336,7 +352,7 @@ public class ResourceResolverControlTest {
 
         assertThat(all.entrySet(), Matchers.hasSize(1));
         assertThat("Resource at /some/path", all.get("/some/path"), not(nullValue()));
-
+        assertSame(somePathResource, all.get("/some/path"));
     }
 
     /**