public void testMakeObjectConnectsAndOtherwiseInitializesConnections() throws LDAPException, UnsupportedEncodingException { setConnectionManagerConfigExpectations(); factory.setConnectionManager(connMgr); mockConn.expects(once()).method("setConnectionManager").with(same(connMgr)); mockConn.expects(once()).method("setConstraints").with(NOT_NULL); // TODO make more specific mockConn .expects(once()) .method("connect") .with(eq(connMgrConfig.getLdapHost()), eq(connMgrConfig.getLdapPort())) .after("setConstraints"); mockConn.expects(once()).method("startTLS").after("connect"); mockConn .expects(once()) .method("bind") .with( eq(LDAPConnection.LDAP_V3), eq(connMgrConfig.getLdapUser()), eq(connMgrConfig.getLdapPassword().getBytes("UTF-8"))) .after("connect"); mockConn.expects(once()).method("setBindAttempted").with(eq(false)).after("bind"); // the actual code exercise assertSame(conn, factory.makeObject()); // TODO how to test socket factory assignment (static call) }
/** * Verifies that {@link PooledLDAPConnectionFactory} is never without a {@link * LdapConnectionLivenessValidator}. */ public void testDefaultsToNativeLdapConnectionLivenessValidatorIfThatPropertySetToNull() { factory.setConnectionLivenessValidator(null); Object livenessValidator = factory.getConnectionLivenessValidator(); assertTrue( "Expected a NativeLdapConnectionLivenessValidator but was [" + livenessValidator + "]", livenessValidator instanceof NativeLdapConnectionLivenessValidator); }
/** * Verifies that {@link PooledLDAPConnectionFactory#validateObject(Object)} does not adjust a * {@link PooledLDAPConnection}'s active flag if the connection appears to be "alive". Probably * overkill, but we've had problems that we think may be related to stale connections being * returned to the pool, so we want to be sure the validate operation is doing exactly what we * think it should be doing. Also verifies that a {@link PooledLDAPConnection}'s search method * returns a LDAPEntry. * * @throws LDAPException */ public void testValidateObjectKeepsActiveFlagUpIfConnectionIsAlive() throws LDAPException { // will fail if the factory attempts to monkey with the active flag factory.setConnectionLivenessValidator(livenessValidator); mockConn.expects(once()).method("isBindAttempted").will(returnValue(false)); mockLivenessValidator.expects(once()).method("isConnectionAlive").will(returnValue(true)); assertTrue(factory.validateObject(conn)); }
/** * Verifies that {@link PooledLDAPConnectionFactory#validateObject(Object)} lowers {@link * PooledLDAPConnection}'s active flag if the current {@link LdapConnectionLivenessValidator} * reports that the connection is not live. * * @throws LDAPException test failure */ public void testValidateObjectLowersActiveFlagIfConnectionIsNotAlive() throws LDAPException { factory.setConnectionLivenessValidator(livenessValidator); mockConn.expects(once()).method("isBindAttempted").will(returnValue(false)); mockLivenessValidator.expects(once()).method("isConnectionAlive").will(returnValue(false)); mockConn .expects(once()) .method("setActive") .with(eq(false)) .after(mockLivenessValidator, "isConnectionAlive"); assertFalse(factory.validateObject(conn)); }
public void testValidateObjectLowersActiveFlagIfLivenessValidationThrowsException() { factory.setConnectionLivenessValidator(livenessValidator); mockConn.expects(once()).method("isBindAttempted").will(returnValue(false)); mockLivenessValidator .expects(once()) .method("isConnectionAlive") .will(throwException(new RuntimeException("catch me"))); mockConn .expects(once()) .method("setActive") .with(eq(false)) .after(mockLivenessValidator, "isConnectionAlive"); assertFalse(factory.validateObject(conn)); }
protected void setUp() throws Exception { mockConn = mock(PooledLDAPConnection.class, "mockConn"); conn = (PooledLDAPConnection) mockConn.proxy(); factory = new PooledLDAPConnectionFactory() { @Override protected PooledLDAPConnection newConnection() { return conn; } }; mockLDAPSearchResults = mock(LDAPSearchResults.class, "mockLDAPSearchResults"); ldapSearchResults = (LDAPSearchResults) mockLDAPSearchResults.proxy(); mockLDAPEntry = mock(LDAPEntry.class, "mockLDAPEntry"); ldapEntry = (LDAPEntry) mockLDAPEntry.proxy(); mockLivenessValidator = new Mock(LdapConnectionLivenessValidator.class); livenessValidator = (LdapConnectionLivenessValidator) mockLivenessValidator.proxy(); factory.setConnectionLivenessValidator(livenessValidator); mockConnMgr = new Mock(LdapConnectionManager.class); connMgr = (LdapConnectionManager) mockConnMgr.proxy(); mockConnMgrConfig = new Mock(LdapConnectionManagerConfig.class); connMgrConfig = (LdapConnectionManagerConfig) mockConnMgrConfig.proxy(); // don't call setConnectionManager() b/c we don't know what expectations to set super.setUp(); }
public void testDestroyObjectIgnoresNonPoolableLdapConnections() { try { factory.destroyObject(mock(LDAPConnection.class).proxy()); } catch (Exception e) { fail("Should have ignored non-poolable connection"); } }
public void testDestroyObjectIgnoresNullReferences() { try { factory.destroyObject(null); } catch (Exception e) { fail("Should have ignored null reference"); } }
/** * If the client has bound the connection but the factory is not running in auto-bind mode, the * connection must be invalidated. */ public void testValidateObjectLowersActiveFlagIfConnectionHasBeenBoundButAutoBindIsNotSet() { mockConn.expects(once()).method("isBindAttempted").will(returnValue(true)); // we assume autoBind defaults to false (we'd rather not go through the // whole process of mocking up the connection manager again) mockConn.expects(once()).method("setActive").with(eq(false)); assertFalse(factory.validateObject(conn)); }
/** * Verifies that {@link PooledLDAPConnectionFactory#activateObject(Object)} passes constraints and * an active flag to the given {@link PooledLDAPConnection}. Does not actually verify constraint * values. * * @throws LDAPException test error */ public void testActivateObject() throws LDAPException { // TODO validate constraint assignment mockConn.expects(once()).method("setConstraints").with(ANYTHING); mockConn.expects(once()).method("setActive").with(eq(true)); factory.activateObject(conn); }
/** * Verifies that a failed rebind during connection validation marks the connection as "inactive". * This ensures that the connection is not returned to the pool by {@link * PooledLDAPConnection#finalize()}. Technically, a failed rebind does not mean the connection is * stale but failing to bind as the system user should indicate that something is very much wrong, * so reallocating a connection is not a bad idea. Certainly better than finding oneself caught in * an endless loop of validating stale connections. */ public void testValidateObjectLowersActiveFlagIfRebindFails() throws UnsupportedEncodingException { setConnectionManagerConfigExpectations(); factory.setConnectionManager(connMgr); LDAPException bindFailure = new LDAPException(); mockConn.expects(once()).method("isBindAttempted").will(returnValue(true)); mockConn .expects(once()) .method("bind") .with( eq(LDAPConnection.LDAP_V3), eq(connMgrConfig.getLdapUser()), eq(connMgrConfig.getLdapPassword().getBytes("UTF-8"))) .after("isBindAttempted") .will(throwException(bindFailure)); mockConn.expects(once()).method("setActive").with(eq(false)).after("bind"); assertFalse(factory.validateObject(conn)); }
/** * Verifies that the {@link PooledLdapConnection} to be validated is re-bound as the system user * prior to testing the connection for liveness. This is only relevant if the client has bound the * connection as another user and the autoBind behavior has been enabled. */ public void testValidateObjectRebindsAsAutoBindUserIfNecessaryPriorToTestingConnectionLiveness() throws UnsupportedEncodingException { setConnectionManagerConfigExpectations(); factory.setConnectionManager(connMgr); mockConn.expects(once()).method("isBindAttempted").will(returnValue(true)); mockConn .expects(once()) .method("bind") .with( eq(LDAPConnection.LDAP_V3), eq(connMgrConfig.getLdapUser()), eq(connMgrConfig.getLdapPassword().getBytes("UTF-8"))) .after("isBindAttempted"); mockConn.expects(once()).method("setBindAttempted").with(eq(false)).after("bind"); mockLivenessValidator.expects(once()).method("isConnectionAlive").will(returnValue(true)); factory.setConnectionLivenessValidator(livenessValidator); assertTrue(factory.validateObject(conn)); }
public void testDestroyObjectInvokesDisconnect() throws Exception { mockConn.expects(once()).method("setActive").with(eq(false)); mockConn.expects(once()).method("disconnect").after("setActive"); factory.destroyObject(conn); }
public void testInvalidatesNullObjects() { assertFalse(factory.validateObject(null)); }