geronimo-connector/src/test/java/org/apache/geronimo/connector/outbound/connectiontracking/ConnectionTrackingCoordinatorProxyTest.java - geronimo-txmanager - 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.geronimo.connector.outbound.connectiontracking;

 import junit.framework.TestCase;
 import org.apache.geronimo.connector.outbound.ConnectionInterceptor;
 import org.apache.geronimo.connector.outbound.ConnectionTrackingInterceptor;
 import org.apache.geronimo.connector.outbound.ConnectionInfo;
 import org.apache.geronimo.connector.outbound.ConnectionReturnAction;
 import org.apache.geronimo.connector.outbound.ManagedConnectionInfo;
 import org.apache.geronimo.connector.outbound.GeronimoConnectionEventListener;

 import javax.security.auth.Subject;
 import javax.resource.ResourceException;
 import javax.resource.spi.ManagedConnection;
 import javax.resource.spi.ConnectionRequestInfo;
 import javax.resource.spi.ConnectionEventListener;
 import javax.resource.spi.LocalTransaction;
 import javax.resource.spi.ManagedConnectionMetaData;
 import javax.transaction.xa.XAResource;
 import java.util.Set;
 import java.util.HashSet;
 import java.util.Map;
 import java.lang.reflect.Proxy;
 import java.io.PrintWriter;

 /**
  * @version $Rev: 476049 $ $Date: 2006-11-16 20:35:17 -0800 (Thu, 16 Nov 2006) $
  */
 public class ConnectionTrackingCoordinatorProxyTest extends TestCase implements ConnectionInterceptor {
     private static final String name1 = "foo";
     private ConnectionTrackingCoordinator connectionTrackingCoordinator;
     private ConnectionTrackingInterceptor key1;
     private Subject subject = null;
     private Set<String> unshareableResources;
     private Set<String> applicationManagedSecurityResources;
     private ManagedConnectionInfo mci;
     private ConnectionImpl connection;

     protected void setUp() throws Exception {
         super.setUp();
         connectionTrackingCoordinator = new ConnectionTrackingCoordinator(true);
         key1 = new ConnectionTrackingInterceptor(this, name1, connectionTrackingCoordinator);
         unshareableResources = new HashSet<String>();
         applicationManagedSecurityResources = new HashSet<String>();

         mci = new ManagedConnectionInfo(null, null);
         mci.setManagedConnection(new MockManagedConnection());
         mci.setConnectionEventListener(new GeronimoConnectionEventListener(this, mci));
         connection = new ConnectionImpl("ConnectionString");
     }

     protected void tearDown() throws Exception {
         connectionTrackingCoordinator = null;
         key1 = null;
         super.tearDown();
     }

     public void testSimpleComponentContextLifecyle() throws Exception {
         // enter component context
         ConnectorInstanceContextImpl componentContext = new ConnectorInstanceContextImpl(unshareableResources, applicationManagedSecurityResources);
         ConnectorInstanceContext oldConnectorInstanceContext = connectionTrackingCoordinator.enter(componentContext);
         assertNull("Expected old instance context to be null", oldConnectorInstanceContext);

         // simulate create connection
         ConnectionInfo connectionInfo = createConnectionInfo();
         connectionTrackingCoordinator.handleObtained(key1, connectionInfo, false);

         // connection should be in component instance context
         Map<ConnectionTrackingInterceptor, Set<ConnectionInfo>> connectionManagerMap = componentContext.getConnectionManagerMap();
         Set<ConnectionInfo> infos = connectionManagerMap.get(key1);
         assertNotNull("Expected one connections for key1", infos);
         assertEquals("Expected one connection for key1", 1, infos.size());
         assertTrue("Expected to get supplied ConnectionInfo from infos", connectionInfo == infos.iterator().next());

         // verify handle
         Object handle = connectionInfo.getConnectionHandle();
         assertNotNull("Expected a handle from ConnectionInfo", handle);
         assertTrue("Expected handle to be an instance of ConnectionImpl", handle instanceof ConnectionImpl);
         ConnectionImpl connection = (ConnectionImpl) handle;
         assertEquals("connection.getString()", "ConnectionString", connection.getString());

         // verify proxy
         Object proxy = connectionInfo.getConnectionProxy();
         assertNotNull("Expected a proxy from ConnectionInfo", proxy);
         assertTrue("Expected proxy to be an instance of Connection", proxy instanceof Connection);
         Connection connectionProxy = (Connection) proxy;
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertSame("Expected connection.getUnmanaged() to be connectionImpl", connection, connectionProxy.getUnmanaged());
         assertNotSame("Expected connection be proxied", connection, connectionProxy);

         // exit component context
         connectionTrackingCoordinator.exit(oldConnectorInstanceContext);

         // connection should not be in context
         connectionManagerMap = componentContext.getConnectionManagerMap();
         infos = connectionManagerMap.get(key1);
         assertEquals("Expected no connection set for key1", null, infos);

         // enter again, and close the handle
         oldConnectorInstanceContext = connectionTrackingCoordinator.enter(componentContext);
         assertNull("Expected old instance context to be null", oldConnectorInstanceContext);
         connectionTrackingCoordinator.handleReleased(key1, connectionInfo, ConnectionReturnAction.DESTROY);
         connectionTrackingCoordinator.exit(oldConnectorInstanceContext);

         // use connection which will cause it to get a new handle if it is not closed
         ConnectionTrackingCoordinator.ConnectionInvocationHandler invocationHandler = (ConnectionTrackingCoordinator.ConnectionInvocationHandler) Proxy.getInvocationHandler(connectionProxy);
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertTrue("Proxy should be connected", invocationHandler.isReleased());
         assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());
     }

     public void testReassociateConnection() throws Exception {
         // enter component context
         ConnectorInstanceContextImpl componentContext = new ConnectorInstanceContextImpl(unshareableResources, applicationManagedSecurityResources);
         ConnectorInstanceContext oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
         assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

         // simulate create connection
         ConnectionInfo connectionInfo = createConnectionInfo();
         connectionTrackingCoordinator.handleObtained(key1, connectionInfo, false);

         // connection should be in component instance context
         Map<ConnectionTrackingInterceptor, Set<ConnectionInfo>> connectionManagerMap = componentContext.getConnectionManagerMap();
         Set<ConnectionInfo> infos = connectionManagerMap.get(key1);
         assertNotNull("Expected one connections for key1", infos);
         assertEquals("Expected one connection for key1", 1, infos.size());
         assertTrue("Expected to get supplied ConnectionInfo from infos", connectionInfo == infos.iterator().next());

         // verify handle
         Object handle = connectionInfo.getConnectionHandle();
         assertNotNull("Expected a handle from ConnectionInfo", handle);
         assertTrue("Expected handle to be an instance of ConnectionImpl", handle instanceof ConnectionImpl);
         ConnectionImpl connection = (ConnectionImpl) handle;
         assertEquals("connection.getString()", "ConnectionString", connection.getString());

         // verify proxy
         Object proxy = connectionInfo.getConnectionProxy();
         assertNotNull("Expected a proxy from ConnectionInfo", proxy);
         assertTrue("Expected proxy to be an instance of Connection", proxy instanceof Connection);
         Connection connectionProxy = (Connection) proxy;
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertSame("Expected connection.getUnmanaged() to be connectionImpl", connection, connectionProxy.getUnmanaged());
         assertNotSame("Expected connection be proxied", connection, connectionProxy);


         // exit outer component context
         connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

         // proxy should be disconnected
         ConnectionTrackingCoordinator.ConnectionInvocationHandler invocationHandler = (ConnectionTrackingCoordinator.ConnectionInvocationHandler) Proxy.getInvocationHandler(connectionProxy);
         assertTrue("Proxy should be disconnected", invocationHandler.isReleased());

         // enter again
         oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
         assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

         // use connection to cause it to get a new handle
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());
         assertNotSame("Expected connection to not be original connection", connection, connectionProxy);

         // destroy handle and exit context
         connectionTrackingCoordinator.handleReleased(key1, connectionInfo, ConnectionReturnAction.DESTROY);
         connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

         // connection should not be in context
         connectionManagerMap = componentContext.getConnectionManagerMap();
         infos = connectionManagerMap.get(key1);
         assertNull("Expected no connection set for key1", infos);

         // use connection which will cause it to get a new handle if it is not closed
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertTrue("Proxy should be connected", invocationHandler.isReleased());
         assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());

     }

     // some code calls the release method using a freshly constructed ContainerInfo without a proxy
     // the ConnectionTrackingCoordinator must find the correct proxy and call releaseHandle or destroy
     public void testReleaseNoProxy() throws Exception {
         // enter component context
         ConnectorInstanceContextImpl componentContext = new ConnectorInstanceContextImpl(unshareableResources, applicationManagedSecurityResources);
         ConnectorInstanceContext oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
         assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

         // simulate create connection
         ConnectionInfo connectionInfo = createConnectionInfo();
         connectionTrackingCoordinator.handleObtained(key1, connectionInfo, false);

         // connection should be in component instance context
         Map<ConnectionTrackingInterceptor, Set<ConnectionInfo>> connectionManagerMap = componentContext.getConnectionManagerMap();
         Set<ConnectionInfo> infos = connectionManagerMap.get(key1);
         assertNotNull("Expected one connections for key1", infos);
         assertEquals("Expected one connection for key1", 1, infos.size());
         assertTrue("Expected to get supplied ConnectionInfo from infos", connectionInfo == infos.iterator().next());

         // verify handle
         Object handle = connectionInfo.getConnectionHandle();
         assertNotNull("Expected a handle from ConnectionInfo", handle);
         assertTrue("Expected handle to be an instance of ConnectionImpl", handle instanceof ConnectionImpl);
         ConnectionImpl connection = (ConnectionImpl) handle;
         assertEquals("connection.getString()", "ConnectionString", connection.getString());

         // verify proxy
         Object proxy = connectionInfo.getConnectionProxy();
         assertNotNull("Expected a proxy from ConnectionInfo", proxy);
         assertTrue("Expected proxy to be an instance of Connection", proxy instanceof Connection);
         Connection connectionProxy = (Connection) proxy;
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertSame("Expected connection.getUnmanaged() to be connectionImpl", connection, connectionProxy.getUnmanaged());
         assertNotSame("Expected connection be proxied", connection, connectionProxy);


         // simulate handle release due to a event listener, which won't hav the proxy
         connectionTrackingCoordinator.handleReleased(key1, createConnectionInfo(), ConnectionReturnAction.RETURN_HANDLE);

         // proxy should be disconnected
         ConnectionTrackingCoordinator.ConnectionInvocationHandler invocationHandler = (ConnectionTrackingCoordinator.ConnectionInvocationHandler) Proxy.getInvocationHandler(connectionProxy);
         assertTrue("Proxy should be disconnected", invocationHandler.isReleased());

         // use connection which will cause it to get a new handle if it is not closed
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertTrue("Proxy should be connected", invocationHandler.isReleased());
         assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());

         // exit outer component context
         connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

         // proxy should be disconnected
         assertTrue("Proxy should be disconnected", invocationHandler.isReleased());

         // connection should not be in context
         connectionManagerMap = componentContext.getConnectionManagerMap();
         infos = connectionManagerMap.get(key1);
         assertNull("Expected no connection set for key1", infos);

         // enter again
         oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
         assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

         // exit context
         connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

         // use connection which will cause it to get a new handle if it is not closed
         assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
         assertTrue("Proxy should be connected", invocationHandler.isReleased());
         assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());
     }


     public Subject mapSubject(Subject sourceSubject) {
         return subject;
     }

     public void getConnection(ConnectionInfo connectionInfo) throws ResourceException {
     }

     public void returnConnection(ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) {
     }

     public void destroy() {
     }

     public void info(StringBuilder s) {
         s.append(getClass().getName()).append("\n");
     }

     private ConnectionInfo createConnectionInfo() {
         ConnectionInfo ci = new ConnectionInfo(mci);
         ci.setConnectionHandle(connection);
         mci.addConnectionHandle(ci);
         return ci;
     }


     public static interface Connection {
         String getString();
         Connection getUnmanaged();
     }

     public static class ConnectionImpl implements Connection {
         private final String string;

         public ConnectionImpl(String string) {
             this.string = string;
         }

         public String getString() {
             return string;
         }

         public Connection getUnmanaged() {
             return this;
         }
     }

     public static class MockManagedConnection implements ManagedConnection {
            public Object getConnection(Subject defaultSubject, ConnectionRequestInfo connectionRequestInfo) throws ResourceException {
                return null;
            }

            public void destroy() throws ResourceException {
            }

            public void cleanup() throws ResourceException {
            }

            public void associateConnection(Object object) throws ResourceException {
            }

            public void addConnectionEventListener(ConnectionEventListener connectionEventListener) {
            }

            public void removeConnectionEventListener(ConnectionEventListener connectionEventListener) {
            }

            public XAResource getXAResource() throws ResourceException {
                return null;
            }

            public LocalTransaction getLocalTransaction() throws ResourceException {
                return null;
            }

            public ManagedConnectionMetaData getMetaData() throws ResourceException {
                return null;
            }

            public void setLogWriter(PrintWriter printWriter) throws ResourceException {
            }

            public PrintWriter getLogWriter() throws ResourceException {
                return null;
            }

            public void dissociateConnections() throws ResourceException {
            }
        }
 }
	/**
	* 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.geronimo.connector.outbound.connectiontracking;

	import junit.framework.TestCase;
	import org.apache.geronimo.connector.outbound.ConnectionInterceptor;
	import org.apache.geronimo.connector.outbound.ConnectionTrackingInterceptor;
	import org.apache.geronimo.connector.outbound.ConnectionInfo;
	import org.apache.geronimo.connector.outbound.ConnectionReturnAction;
	import org.apache.geronimo.connector.outbound.ManagedConnectionInfo;
	import org.apache.geronimo.connector.outbound.GeronimoConnectionEventListener;

	import javax.security.auth.Subject;
	import javax.resource.ResourceException;
	import javax.resource.spi.ManagedConnection;
	import javax.resource.spi.ConnectionRequestInfo;
	import javax.resource.spi.ConnectionEventListener;
	import javax.resource.spi.LocalTransaction;
	import javax.resource.spi.ManagedConnectionMetaData;
	import javax.transaction.xa.XAResource;
	import java.util.Set;
	import java.util.HashSet;
	import java.util.Map;
	import java.lang.reflect.Proxy;
	import java.io.PrintWriter;

	/**
	* @version $Rev: 476049 $ $Date: 2006-11-16 20:35:17 -0800 (Thu, 16 Nov 2006) $
	*/
	public class ConnectionTrackingCoordinatorProxyTest extends TestCase implements ConnectionInterceptor {
	private static final String name1 = "foo";
	private ConnectionTrackingCoordinator connectionTrackingCoordinator;
	private ConnectionTrackingInterceptor key1;
	private Subject subject = null;
	private Set<String> unshareableResources;
	private Set<String> applicationManagedSecurityResources;
	private ManagedConnectionInfo mci;
	private ConnectionImpl connection;

	protected void setUp() throws Exception {
	super.setUp();
	connectionTrackingCoordinator = new ConnectionTrackingCoordinator(true);
	key1 = new ConnectionTrackingInterceptor(this, name1, connectionTrackingCoordinator);
	unshareableResources = new HashSet<String>();
	applicationManagedSecurityResources = new HashSet<String>();

	mci = new ManagedConnectionInfo(null, null);
	mci.setManagedConnection(new MockManagedConnection());
	mci.setConnectionEventListener(new GeronimoConnectionEventListener(this, mci));
	connection = new ConnectionImpl("ConnectionString");
	}

	protected void tearDown() throws Exception {
	connectionTrackingCoordinator = null;
	key1 = null;
	super.tearDown();
	}

	public void testSimpleComponentContextLifecyle() throws Exception {
	// enter component context
	ConnectorInstanceContextImpl componentContext = new ConnectorInstanceContextImpl(unshareableResources, applicationManagedSecurityResources);
	ConnectorInstanceContext oldConnectorInstanceContext = connectionTrackingCoordinator.enter(componentContext);
	assertNull("Expected old instance context to be null", oldConnectorInstanceContext);

	// simulate create connection
	ConnectionInfo connectionInfo = createConnectionInfo();
	connectionTrackingCoordinator.handleObtained(key1, connectionInfo, false);

	// connection should be in component instance context
	Map<ConnectionTrackingInterceptor, Set<ConnectionInfo>> connectionManagerMap = componentContext.getConnectionManagerMap();
	Set<ConnectionInfo> infos = connectionManagerMap.get(key1);
	assertNotNull("Expected one connections for key1", infos);
	assertEquals("Expected one connection for key1", 1, infos.size());
	assertTrue("Expected to get supplied ConnectionInfo from infos", connectionInfo == infos.iterator().next());

	// verify handle
	Object handle = connectionInfo.getConnectionHandle();
	assertNotNull("Expected a handle from ConnectionInfo", handle);
	assertTrue("Expected handle to be an instance of ConnectionImpl", handle instanceof ConnectionImpl);
	ConnectionImpl connection = (ConnectionImpl) handle;
	assertEquals("connection.getString()", "ConnectionString", connection.getString());

	// verify proxy
	Object proxy = connectionInfo.getConnectionProxy();
	assertNotNull("Expected a proxy from ConnectionInfo", proxy);
	assertTrue("Expected proxy to be an instance of Connection", proxy instanceof Connection);
	Connection connectionProxy = (Connection) proxy;
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertSame("Expected connection.getUnmanaged() to be connectionImpl", connection, connectionProxy.getUnmanaged());
	assertNotSame("Expected connection be proxied", connection, connectionProxy);

	// exit component context
	connectionTrackingCoordinator.exit(oldConnectorInstanceContext);

	// connection should not be in context
	connectionManagerMap = componentContext.getConnectionManagerMap();
	infos = connectionManagerMap.get(key1);
	assertEquals("Expected no connection set for key1", null, infos);

	// enter again, and close the handle
	oldConnectorInstanceContext = connectionTrackingCoordinator.enter(componentContext);
	assertNull("Expected old instance context to be null", oldConnectorInstanceContext);
	connectionTrackingCoordinator.handleReleased(key1, connectionInfo, ConnectionReturnAction.DESTROY);
	connectionTrackingCoordinator.exit(oldConnectorInstanceContext);

	// use connection which will cause it to get a new handle if it is not closed
	ConnectionTrackingCoordinator.ConnectionInvocationHandler invocationHandler = (ConnectionTrackingCoordinator.ConnectionInvocationHandler) Proxy.getInvocationHandler(connectionProxy);
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertTrue("Proxy should be connected", invocationHandler.isReleased());
	assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());
	}

	public void testReassociateConnection() throws Exception {
	// enter component context
	ConnectorInstanceContextImpl componentContext = new ConnectorInstanceContextImpl(unshareableResources, applicationManagedSecurityResources);
	ConnectorInstanceContext oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
	assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

	// simulate create connection
	ConnectionInfo connectionInfo = createConnectionInfo();
	connectionTrackingCoordinator.handleObtained(key1, connectionInfo, false);

	// connection should be in component instance context
	Map<ConnectionTrackingInterceptor, Set<ConnectionInfo>> connectionManagerMap = componentContext.getConnectionManagerMap();
	Set<ConnectionInfo> infos = connectionManagerMap.get(key1);
	assertNotNull("Expected one connections for key1", infos);
	assertEquals("Expected one connection for key1", 1, infos.size());
	assertTrue("Expected to get supplied ConnectionInfo from infos", connectionInfo == infos.iterator().next());

	// verify handle
	Object handle = connectionInfo.getConnectionHandle();
	assertNotNull("Expected a handle from ConnectionInfo", handle);
	assertTrue("Expected handle to be an instance of ConnectionImpl", handle instanceof ConnectionImpl);
	ConnectionImpl connection = (ConnectionImpl) handle;
	assertEquals("connection.getString()", "ConnectionString", connection.getString());

	// verify proxy
	Object proxy = connectionInfo.getConnectionProxy();
	assertNotNull("Expected a proxy from ConnectionInfo", proxy);
	assertTrue("Expected proxy to be an instance of Connection", proxy instanceof Connection);
	Connection connectionProxy = (Connection) proxy;
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertSame("Expected connection.getUnmanaged() to be connectionImpl", connection, connectionProxy.getUnmanaged());
	assertNotSame("Expected connection be proxied", connection, connectionProxy);


	// exit outer component context
	connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

	// proxy should be disconnected
	ConnectionTrackingCoordinator.ConnectionInvocationHandler invocationHandler = (ConnectionTrackingCoordinator.ConnectionInvocationHandler) Proxy.getInvocationHandler(connectionProxy);
	assertTrue("Proxy should be disconnected", invocationHandler.isReleased());

	// enter again
	oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
	assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

	// use connection to cause it to get a new handle
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());
	assertNotSame("Expected connection to not be original connection", connection, connectionProxy);

	// destroy handle and exit context
	connectionTrackingCoordinator.handleReleased(key1, connectionInfo, ConnectionReturnAction.DESTROY);
	connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

	// connection should not be in context
	connectionManagerMap = componentContext.getConnectionManagerMap();
	infos = connectionManagerMap.get(key1);
	assertNull("Expected no connection set for key1", infos);

	// use connection which will cause it to get a new handle if it is not closed
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertTrue("Proxy should be connected", invocationHandler.isReleased());
	assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());

	}

	// some code calls the release method using a freshly constructed ContainerInfo without a proxy
	// the ConnectionTrackingCoordinator must find the correct proxy and call releaseHandle or destroy
	public void testReleaseNoProxy() throws Exception {
	// enter component context
	ConnectorInstanceContextImpl componentContext = new ConnectorInstanceContextImpl(unshareableResources, applicationManagedSecurityResources);
	ConnectorInstanceContext oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
	assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

	// simulate create connection
	ConnectionInfo connectionInfo = createConnectionInfo();
	connectionTrackingCoordinator.handleObtained(key1, connectionInfo, false);

	// connection should be in component instance context
	Map<ConnectionTrackingInterceptor, Set<ConnectionInfo>> connectionManagerMap = componentContext.getConnectionManagerMap();
	Set<ConnectionInfo> infos = connectionManagerMap.get(key1);
	assertNotNull("Expected one connections for key1", infos);
	assertEquals("Expected one connection for key1", 1, infos.size());
	assertTrue("Expected to get supplied ConnectionInfo from infos", connectionInfo == infos.iterator().next());

	// verify handle
	Object handle = connectionInfo.getConnectionHandle();
	assertNotNull("Expected a handle from ConnectionInfo", handle);
	assertTrue("Expected handle to be an instance of ConnectionImpl", handle instanceof ConnectionImpl);
	ConnectionImpl connection = (ConnectionImpl) handle;
	assertEquals("connection.getString()", "ConnectionString", connection.getString());

	// verify proxy
	Object proxy = connectionInfo.getConnectionProxy();
	assertNotNull("Expected a proxy from ConnectionInfo", proxy);
	assertTrue("Expected proxy to be an instance of Connection", proxy instanceof Connection);
	Connection connectionProxy = (Connection) proxy;
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertSame("Expected connection.getUnmanaged() to be connectionImpl", connection, connectionProxy.getUnmanaged());
	assertNotSame("Expected connection be proxied", connection, connectionProxy);


	// simulate handle release due to a event listener, which won't hav the proxy
	connectionTrackingCoordinator.handleReleased(key1, createConnectionInfo(), ConnectionReturnAction.RETURN_HANDLE);

	// proxy should be disconnected
	ConnectionTrackingCoordinator.ConnectionInvocationHandler invocationHandler = (ConnectionTrackingCoordinator.ConnectionInvocationHandler) Proxy.getInvocationHandler(connectionProxy);
	assertTrue("Proxy should be disconnected", invocationHandler.isReleased());

	// use connection which will cause it to get a new handle if it is not closed
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertTrue("Proxy should be connected", invocationHandler.isReleased());
	assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());

	// exit outer component context
	connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

	// proxy should be disconnected
	assertTrue("Proxy should be disconnected", invocationHandler.isReleased());

	// connection should not be in context
	connectionManagerMap = componentContext.getConnectionManagerMap();
	infos = connectionManagerMap.get(key1);
	assertNull("Expected no connection set for key1", infos);

	// enter again
	oldConnectorInstanceContext1 = connectionTrackingCoordinator.enter(componentContext);
	assertNull("Expected old component context to be null", oldConnectorInstanceContext1);

	// exit context
	connectionTrackingCoordinator.exit(oldConnectorInstanceContext1);

	// use connection which will cause it to get a new handle if it is not closed
	assertEquals("connection.getString()", "ConnectionString", connectionProxy.getString());
	assertTrue("Proxy should be connected", invocationHandler.isReleased());
	assertSame("Expected connection.getUnmanaged() to be original connection", connection, connection.getUnmanaged());
	}


	public Subject mapSubject(Subject sourceSubject) {
	return subject;
	}

	public void getConnection(ConnectionInfo connectionInfo) throws ResourceException {
	}

	public void returnConnection(ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) {
	}

	public void destroy() {
	}

	public void info(StringBuilder s) {
	s.append(getClass().getName()).append("\n");
	}

	private ConnectionInfo createConnectionInfo() {
	ConnectionInfo ci = new ConnectionInfo(mci);
	ci.setConnectionHandle(connection);
	mci.addConnectionHandle(ci);
	return ci;
	}


	public static interface Connection {
	String getString();
	Connection getUnmanaged();
	}

	public static class ConnectionImpl implements Connection {
	private final String string;

	public ConnectionImpl(String string) {
	this.string = string;
	}

	public String getString() {
	return string;
	}

	public Connection getUnmanaged() {
	return this;
	}
	}

	public static class MockManagedConnection implements ManagedConnection {
	public Object getConnection(Subject defaultSubject, ConnectionRequestInfo connectionRequestInfo) throws ResourceException {
	return null;
	}

	public void destroy() throws ResourceException {
	}

	public void cleanup() throws ResourceException {
	}

	public void associateConnection(Object object) throws ResourceException {
	}

	public void addConnectionEventListener(ConnectionEventListener connectionEventListener) {
	}

	public void removeConnectionEventListener(ConnectionEventListener connectionEventListener) {
	}

	public XAResource getXAResource() throws ResourceException {
	return null;
	}

	public LocalTransaction getLocalTransaction() throws ResourceException {
	return null;
	}

	public ManagedConnectionMetaData getMetaData() throws ResourceException {
	return null;
	}

	public void setLogWriter(PrintWriter printWriter) throws ResourceException {
	}

	public PrintWriter getLogWriter() throws ResourceException {
	return null;
	}

	public void dissociateConnections() throws ResourceException {
	}
	}
	}