src/test/java/org/apache/sling/jcr/resource/internal/helper/jcr/JcrResourceProviderSessionHandlingTest.java - sling-org-apache-sling-jcr-resource - 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.jcr.resource.internal.helper.jcr;

 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.not;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeThat;
 import static org.junit.Assume.assumeTrue;
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import javax.jcr.Credentials;
 import javax.jcr.LoginException;
 import javax.jcr.NoSuchWorkspaceException;
 import javax.jcr.RepositoryException;
 import javax.jcr.Session;
 import javax.jcr.Value;

 import org.apache.sling.api.resource.ResourceResolver;
 import org.apache.sling.api.resource.ResourceResolverFactory;
 import org.apache.sling.jcr.api.SlingRepository;
 import org.apache.sling.jcr.resource.api.JcrResourceConstants;
 import org.apache.sling.spi.resource.provider.ResolveContext;
 import org.apache.sling.spi.resource.provider.ResourceProvider;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.Parameterized.Parameters;
 import org.mockito.Matchers;
 import org.mockito.Mockito;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.component.ComponentContext;

 @RunWith(Parameterized.class)
 public class JcrResourceProviderSessionHandlingTest {

     private enum LoginStyle {USER, SESSION, SERVICE};

     private static final String AUTH_USER = "admin";
     private static final char[] AUTH_PASSWORD = "admin".toCharArray();
     private static final String SUDO_USER = "anonymous";

     @Parameters(name = "loginStyle= {0}, sudo = {1}, clone = {2}")
     public static List<Object[]> data() {

         LoginStyle[] loginStyles = LoginStyle.values();
         boolean[] sudoOptions = new boolean[] {false, true};
         boolean[] cloneOptions = new boolean[] {false, true};

         // Generate all possible combinations into data.
         List<Object[]> data = new ArrayList<>();
         Object[] dataPoint = new Object[3];
         for (LoginStyle loginStyle : loginStyles) {
             dataPoint[0] = loginStyle;
             for (boolean sudo : sudoOptions) {
                 dataPoint[1] = sudo;
                 for (boolean clone : cloneOptions) {
                     dataPoint[2] = clone;
                     data.add(dataPoint.clone());
                 }
             }
         }
         return data;
     }

     @Parameter(0)
     public LoginStyle loginStyle;

     @Parameter(1)
     public boolean useSudo;

     @Parameter(2)
     public boolean doClone;

     // Session we're using when loginStyle == SESSION, null otherwise.
     private Session explicitSession;
     // TransientRepository has a bug that makes it ignore sessions created
     // by calling Session.impersonate(). To prevent the repo from closing
     // prematurely, have this dummy session open during the whole lifetime
     // of the test.
     private Session footInDoor;

     private JcrResourceProvider jcrResourceProvider;
     private JcrProviderState jcrProviderState;

     private static class SlingRepositoryWithDummyServiceUsers implements SlingRepository {
         private final SlingRepository wrapped;

         SlingRepositoryWithDummyServiceUsers(SlingRepository wrapped) {
             this.wrapped = wrapped;
         }

         @SuppressWarnings("deprecation")
         @Override
         public Session loginService(String subServiceName, String workspace)
                 throws LoginException, RepositoryException {
             // just fake service logins by doing administrative logins instead
             return wrapped.loginAdministrative(workspace);
         }

         // the rest of the methods just delegate to wrapped

         @Override
         public String[] getDescriptorKeys() {
             return wrapped.getDescriptorKeys();
         }

         @Override
         public boolean isStandardDescriptor(String key) {
             return wrapped.isStandardDescriptor(key);
         }

         @Override
         public boolean isSingleValueDescriptor(String key) {
             return wrapped.isSingleValueDescriptor(key);
         }

         @Override
         public Value getDescriptorValue(String key) {
             return wrapped.getDescriptorValue(key);
         }

         @Override
         public Value[] getDescriptorValues(String key) {
             return wrapped.getDescriptorValues(key);
         }

         @Override
         public String getDescriptor(String key) {
             return wrapped.getDescriptor(key);
         }

         @Override
         public Session login(Credentials credentials, String workspaceName)
                 throws LoginException, NoSuchWorkspaceException, RepositoryException {
             return wrapped.login(credentials, workspaceName);
         }

         @Override
         public Session login(Credentials credentials) throws LoginException, RepositoryException {
             return wrapped.login(credentials);
         }

         @Override
         public Session login(String workspaceName)
                 throws LoginException, NoSuchWorkspaceException, RepositoryException {
             return wrapped.login(workspaceName);
         }

         @Override
         public Session login() throws LoginException, RepositoryException {
             return wrapped.login();
         }

         @Override
         public String getDefaultWorkspace() {
             return wrapped.getDefaultWorkspace();
         }

         @SuppressWarnings("deprecation")
         @Override
         public Session loginAdministrative(String workspace) throws LoginException, RepositoryException {
             return wrapped.loginAdministrative(workspace);
         }

     }

     @Before
     public void setUp() throws Exception {
         final SlingRepository repo = new SlingRepositoryWithDummyServiceUsers(SlingRepositoryProvider.getRepository());

         footInDoor = repo.loginAdministrative(null);

         Map<String, Object> authInfo = new HashMap<>();
         switch (loginStyle) {
         case USER:
             authInfo.put(ResourceResolverFactory.USER, AUTH_USER);
             authInfo.put(ResourceResolverFactory.PASSWORD, AUTH_PASSWORD);
             break;
         case SESSION:
             explicitSession = repo.loginAdministrative(null);
             authInfo.put(JcrResourceConstants.AUTHENTICATION_INFO_SESSION, explicitSession);
             break;
         case SERVICE:
             Bundle mockBundle = mock(Bundle.class);
             BundleContext mockBundleContext = mock(BundleContext.class);
             when(mockBundle.getBundleContext()).thenReturn(mockBundleContext);
             when(mockBundleContext.getService(Matchers.<ServiceReference<Object>>any())).thenReturn(repo);
             authInfo.put(ResourceResolverFactory.SUBSERVICE, "dummy-service");
             authInfo.put(ResourceProvider.AUTH_SERVICE_BUNDLE, mockBundle);
             break;
         }

         if (useSudo) {
             authInfo.put(ResourceResolverFactory.USER_IMPERSONATION, SUDO_USER);
         }

         if (doClone) {
             authInfo.put(ResourceProvider.AUTH_CLONE, true);
         }

         ComponentContext ctx = mock(ComponentContext.class);
         when(ctx.locateService(anyString(), Mockito.<ServiceReference<Object>>any())).thenReturn(repo);

         jcrResourceProvider = new JcrResourceProvider();
         jcrResourceProvider.activate(ctx);

         jcrProviderState = jcrResourceProvider.authenticate(authInfo);
     }

     @After
     public void tearDown() throws Exception {

         // Some tests do a logout, so check for liveness before trying to log out.
         if (jcrProviderState.getSession().isLive()) {
             jcrResourceProvider.logout(jcrProviderState);
         }

         jcrResourceProvider.deactivate();

         if (explicitSession != null) {
             explicitSession.logout();
         }

         footInDoor.logout();
     }

     @Test
     public void returnedSessionIsLive() {
         assertTrue(jcrProviderState.getSession().isLive());
     }

     @Test
     public void sessionUsesCorrectUser() {
         String expectedUser = useSudo ? SUDO_USER : AUTH_USER;
         assertEquals(expectedUser, jcrProviderState.getSession().getUserID());
     }

     @Test
     public void explicitSessionNotClosedOnLogout() {
         assumeTrue(loginStyle == LoginStyle.SESSION);

         jcrResourceProvider.logout(jcrProviderState);

         assertTrue(explicitSession.isLive());
     }

     @Test
     public void sessionsDoNotLeak() {
         // This test is only valid if we either didn't pass an explicit session,
         // or the provider had to clone it. Sessions created by the provider
         // must be closed by the provider, or we have a session leak.
         assumeThat(jcrProviderState.getSession(), is(not(sameInstance(explicitSession))));

         jcrResourceProvider.logout(jcrProviderState);

         assertFalse(jcrProviderState.getSession().isLive());
     }

     @Test
     public void impersonatorIsReportedCorrectly() {
         assumeTrue(useSudo);

         @SuppressWarnings("unchecked")
         ResolveContext<JcrProviderState> mockContext = mock(ResolveContext.class);
         when(mockContext.getProviderState()).thenReturn(jcrProviderState);
         Object reportedImpersonator = jcrResourceProvider.getAttribute(mockContext, ResourceResolver.USER_IMPERSONATOR);

         assertEquals(AUTH_USER, reportedImpersonator);
     }

     @Test
     public void clonesAreIndependent() {
         assumeTrue(loginStyle == LoginStyle.SESSION && doClone);

         assertNotSame(explicitSession, jcrProviderState.getSession());
     }

 }
	/*
	* 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.jcr.resource.internal.helper.jcr;

	import static org.hamcrest.Matchers.is;
	import static org.hamcrest.Matchers.not;
	import static org.hamcrest.Matchers.sameInstance;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotSame;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assume.assumeThat;
	import static org.junit.Assume.assumeTrue;
	import static org.mockito.Matchers.anyString;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.when;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import javax.jcr.Credentials;
	import javax.jcr.LoginException;
	import javax.jcr.NoSuchWorkspaceException;
	import javax.jcr.RepositoryException;
	import javax.jcr.Session;
	import javax.jcr.Value;

	import org.apache.sling.api.resource.ResourceResolver;
	import org.apache.sling.api.resource.ResourceResolverFactory;
	import org.apache.sling.jcr.api.SlingRepository;
	import org.apache.sling.jcr.resource.api.JcrResourceConstants;
	import org.apache.sling.spi.resource.provider.ResolveContext;
	import org.apache.sling.spi.resource.provider.ResourceProvider;
	import org.junit.After;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.Parameterized;
	import org.junit.runners.Parameterized.Parameter;
	import org.junit.runners.Parameterized.Parameters;
	import org.mockito.Matchers;
	import org.mockito.Mockito;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.ServiceReference;
	import org.osgi.service.component.ComponentContext;

	@RunWith(Parameterized.class)
	public class JcrResourceProviderSessionHandlingTest {

	private enum LoginStyle {USER, SESSION, SERVICE};

	private static final String AUTH_USER = "admin";
	private static final char[] AUTH_PASSWORD = "admin".toCharArray();
	private static final String SUDO_USER = "anonymous";

	@Parameters(name = "loginStyle= {0}, sudo = {1}, clone = {2}")
	public static List<Object[]> data() {

	LoginStyle[] loginStyles = LoginStyle.values();
	boolean[] sudoOptions = new boolean[] {false, true};
	boolean[] cloneOptions = new boolean[] {false, true};

	// Generate all possible combinations into data.
	List<Object[]> data = new ArrayList<>();
	Object[] dataPoint = new Object[3];
	for (LoginStyle loginStyle : loginStyles) {
	dataPoint[0] = loginStyle;
	for (boolean sudo : sudoOptions) {
	dataPoint[1] = sudo;
	for (boolean clone : cloneOptions) {
	dataPoint[2] = clone;
	data.add(dataPoint.clone());
	}
	}
	}
	return data;
	}

	@Parameter(0)
	public LoginStyle loginStyle;

	@Parameter(1)
	public boolean useSudo;

	@Parameter(2)
	public boolean doClone;

	// Session we're using when loginStyle == SESSION, null otherwise.
	private Session explicitSession;
	// TransientRepository has a bug that makes it ignore sessions created
	// by calling Session.impersonate(). To prevent the repo from closing
	// prematurely, have this dummy session open during the whole lifetime
	// of the test.
	private Session footInDoor;

	private JcrResourceProvider jcrResourceProvider;
	private JcrProviderState jcrProviderState;

	private static class SlingRepositoryWithDummyServiceUsers implements SlingRepository {
	private final SlingRepository wrapped;

	SlingRepositoryWithDummyServiceUsers(SlingRepository wrapped) {
	this.wrapped = wrapped;
	}

	@SuppressWarnings("deprecation")
	@Override
	public Session loginService(String subServiceName, String workspace)
	throws LoginException, RepositoryException {
	// just fake service logins by doing administrative logins instead
	return wrapped.loginAdministrative(workspace);
	}

	// the rest of the methods just delegate to wrapped

	@Override
	public String[] getDescriptorKeys() {
	return wrapped.getDescriptorKeys();
	}

	@Override
	public boolean isStandardDescriptor(String key) {
	return wrapped.isStandardDescriptor(key);
	}

	@Override
	public boolean isSingleValueDescriptor(String key) {
	return wrapped.isSingleValueDescriptor(key);
	}

	@Override
	public Value getDescriptorValue(String key) {
	return wrapped.getDescriptorValue(key);
	}

	@Override
	public Value[] getDescriptorValues(String key) {
	return wrapped.getDescriptorValues(key);
	}

	@Override
	public String getDescriptor(String key) {
	return wrapped.getDescriptor(key);
	}

	@Override
	public Session login(Credentials credentials, String workspaceName)
	throws LoginException, NoSuchWorkspaceException, RepositoryException {
	return wrapped.login(credentials, workspaceName);
	}

	@Override
	public Session login(Credentials credentials) throws LoginException, RepositoryException {
	return wrapped.login(credentials);
	}

	@Override
	public Session login(String workspaceName)
	throws LoginException, NoSuchWorkspaceException, RepositoryException {
	return wrapped.login(workspaceName);
	}

	@Override
	public Session login() throws LoginException, RepositoryException {
	return wrapped.login();
	}

	@Override
	public String getDefaultWorkspace() {
	return wrapped.getDefaultWorkspace();
	}

	@SuppressWarnings("deprecation")
	@Override
	public Session loginAdministrative(String workspace) throws LoginException, RepositoryException {
	return wrapped.loginAdministrative(workspace);
	}

	}

	@Before
	public void setUp() throws Exception {
	final SlingRepository repo = new SlingRepositoryWithDummyServiceUsers(SlingRepositoryProvider.getRepository());

	footInDoor = repo.loginAdministrative(null);

	Map<String, Object> authInfo = new HashMap<>();
	switch (loginStyle) {
	case USER:
	authInfo.put(ResourceResolverFactory.USER, AUTH_USER);
	authInfo.put(ResourceResolverFactory.PASSWORD, AUTH_PASSWORD);
	break;
	case SESSION:
	explicitSession = repo.loginAdministrative(null);
	authInfo.put(JcrResourceConstants.AUTHENTICATION_INFO_SESSION, explicitSession);
	break;
	case SERVICE:
	Bundle mockBundle = mock(Bundle.class);
	BundleContext mockBundleContext = mock(BundleContext.class);
	when(mockBundle.getBundleContext()).thenReturn(mockBundleContext);
	when(mockBundleContext.getService(Matchers.<ServiceReference<Object>>any())).thenReturn(repo);
	authInfo.put(ResourceResolverFactory.SUBSERVICE, "dummy-service");
	authInfo.put(ResourceProvider.AUTH_SERVICE_BUNDLE, mockBundle);
	break;
	}

	if (useSudo) {
	authInfo.put(ResourceResolverFactory.USER_IMPERSONATION, SUDO_USER);
	}

	if (doClone) {
	authInfo.put(ResourceProvider.AUTH_CLONE, true);
	}

	ComponentContext ctx = mock(ComponentContext.class);
	when(ctx.locateService(anyString(), Mockito.<ServiceReference<Object>>any())).thenReturn(repo);

	jcrResourceProvider = new JcrResourceProvider();
	jcrResourceProvider.activate(ctx);

	jcrProviderState = jcrResourceProvider.authenticate(authInfo);
	}

	@After
	public void tearDown() throws Exception {

	// Some tests do a logout, so check for liveness before trying to log out.
	if (jcrProviderState.getSession().isLive()) {
	jcrResourceProvider.logout(jcrProviderState);
	}

	jcrResourceProvider.deactivate();

	if (explicitSession != null) {
	explicitSession.logout();
	}

	footInDoor.logout();
	}

	@Test
	public void returnedSessionIsLive() {
	assertTrue(jcrProviderState.getSession().isLive());
	}

	@Test
	public void sessionUsesCorrectUser() {
	String expectedUser = useSudo ? SUDO_USER : AUTH_USER;
	assertEquals(expectedUser, jcrProviderState.getSession().getUserID());
	}

	@Test
	public void explicitSessionNotClosedOnLogout() {
	assumeTrue(loginStyle == LoginStyle.SESSION);

	jcrResourceProvider.logout(jcrProviderState);

	assertTrue(explicitSession.isLive());
	}

	@Test
	public void sessionsDoNotLeak() {
	// This test is only valid if we either didn't pass an explicit session,
	// or the provider had to clone it. Sessions created by the provider
	// must be closed by the provider, or we have a session leak.
	assumeThat(jcrProviderState.getSession(), is(not(sameInstance(explicitSession))));

	jcrResourceProvider.logout(jcrProviderState);

	assertFalse(jcrProviderState.getSession().isLive());
	}

	@Test
	public void impersonatorIsReportedCorrectly() {
	assumeTrue(useSudo);

	@SuppressWarnings("unchecked")
	ResolveContext<JcrProviderState> mockContext = mock(ResolveContext.class);
	when(mockContext.getProviderState()).thenReturn(jcrProviderState);
	Object reportedImpersonator = jcrResourceProvider.getAttribute(mockContext, ResourceResolver.USER_IMPERSONATOR);

	assertEquals(AUTH_USER, reportedImpersonator);
	}

	@Test
	public void clonesAreIndependent() {
	assumeTrue(loginStyle == LoginStyle.SESSION && doClone);

	assertNotSame(explicitSession, jcrProviderState.getSession());
	}

	}