http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/datasources/TestInstanceKeyDataSource.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbcp2/datasources/TestInstanceKeyDataSource.java b/src/test/java/org/apache/commons/dbcp2/datasources/TestInstanceKeyDataSource.java index 654a677..1a875d0 100644 --- a/src/test/java/org/apache/commons/dbcp2/datasources/TestInstanceKeyDataSource.java +++ b/src/test/java/org/apache/commons/dbcp2/datasources/TestInstanceKeyDataSource.java @@ -18,37 +18,63 @@ package org.apache.commons.dbcp2.datasources; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; +import java.io.PrintWriter; import java.sql.Connection; import java.sql.SQLException; +import java.util.Properties; import org.apache.commons.dbcp2.cpdsadapter.DriverAdapterCPDS; +import org.junit.After; +import org.junit.Before; import org.junit.Test; /** */ public class TestInstanceKeyDataSource { + private DriverAdapterCPDS pcds; + private SharedPoolDataSource spds; + + private final static String DRIVER = "org.apache.commons.dbcp2.TesterDriver"; + private final static String URL = "jdbc:apache:commons:testdriver"; + private final static String USER = "foo"; + private final static String PASS = "bar"; + + @Before + public void setUp() throws ClassNotFoundException { + pcds = new DriverAdapterCPDS(); + pcds.setDriver(DRIVER); + pcds.setUrl(URL); + pcds.setUser(USER); + pcds.setPassword(PASS); + pcds.setPoolPreparedStatements(false); + spds = new SharedPoolDataSource(); + spds.setConnectionPoolDataSource(pcds); + } + + @After + public void tearDown() throws Exception { + spds.close(); + } + /** * Verify that exception on setupDefaults does not leak PooledConnection * * JIRA: DBCP-237 + * @throws Exception */ @Test public void testExceptionOnSetupDefaults() throws Exception { - DriverAdapterCPDS pcds; - pcds = new DriverAdapterCPDS(); - pcds.setDriver("org.apache.commons.dbcp2.TesterDriver"); - pcds.setUrl("jdbc:apache:commons:testdriver"); - pcds.setUser("foo"); - pcds.setPassword("bar"); - pcds.setPoolPreparedStatements(false); - final ThrowOnSetupDefaultsDataSource tds = new ThrowOnSetupDefaultsDataSource(); - tds.setConnectionPoolDataSource(pcds); + ThrowOnSetupDefaultsDataSource tds = new ThrowOnSetupDefaultsDataSource(); final int numConnections = tds.getNumActive(); try { - tds.getConnection("foo", "bar"); + tds.getConnection(USER, PASS); fail("Expecting SQLException"); } catch (final SQLException ex) { //Expected @@ -71,4 +97,215 @@ public class TestInstanceKeyDataSource { } } + @Test + public void testConnectionPoolDataSource() { + assertEquals(pcds, spds.getConnectionPoolDataSource()); + } + + @Test(expected=IllegalStateException.class) + public void testConnectionPoolDataSourceAlreadySet() { + spds.setConnectionPoolDataSource(new DriverAdapterCPDS()); + } + + @Test(expected=IllegalStateException.class) + public void testConnectionPoolDataSourceAlreadySetUsingJndi() { + spds = new SharedPoolDataSource(); + spds.setDataSourceName("anything"); + spds.setConnectionPoolDataSource(new DriverAdapterCPDS()); + } + + @Test + public void testDataSourceName() { + spds = new SharedPoolDataSource(); + assertNull(spds.getDataSourceName()); + spds.setDataSourceName("anything"); + assertEquals("anything", spds.getDataSourceName()); + } + + @Test(expected=IllegalStateException.class) + public void testDataSourceNameAlreadySet() { + spds.setDataSourceName("anything"); + } + + @Test(expected=IllegalStateException.class) + public void testDataSourceNameAlreadySetUsingJndi() { + spds = new SharedPoolDataSource(); + spds.setDataSourceName("anything"); + spds.setDataSourceName("anything"); + } + + @Test + public void testDefaultTransactionIsolation() { + assertEquals(SharedPoolDataSource.UNKNOWN_TRANSACTIONISOLATION, spds.getDefaultTransactionIsolation()); + spds.setDefaultTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); + assertEquals(Connection.TRANSACTION_READ_COMMITTED, spds.getDefaultTransactionIsolation()); + } + + @Test(expected=IllegalArgumentException.class) + public void testDefaultTransactionIsolationInvalid() { + assertEquals(SharedPoolDataSource.UNKNOWN_TRANSACTIONISOLATION, spds.getDefaultTransactionIsolation()); + spds.setDefaultTransactionIsolation(Integer.MAX_VALUE); + } + + @Test + public void testDescription() { + spds.setDescription("anything"); + assertEquals("anything", spds.getDescription()); + } + + @Test(expected=NullPointerException.class) + public void testJndiNullProperties() { + spds.setJndiEnvironment(null); + } + + @Test + public void testJndiPropertiesNotInitialized() { + assertNull(spds.getJndiEnvironment("name")); + spds.setJndiEnvironment("name", "king"); + assertEquals("king", spds.getJndiEnvironment("name")); + } + + @Test + public void testJndiPropertiesCleared() { + spds.setJndiEnvironment("name", "king"); + assertEquals("king", spds.getJndiEnvironment("name")); + Properties properties = new Properties(); + properties.setProperty("fish", "kohi"); + spds.setJndiEnvironment(properties); + assertNull(spds.getJndiEnvironment("name")); + } + + @Test + public void testJndiEnvironment() { + assertNull(spds.getJndiEnvironment("name")); + Properties properties = new Properties(); + properties.setProperty("name", "clarke"); + spds.setJndiEnvironment(properties); + assertEquals("clarke", spds.getJndiEnvironment("name")); + spds.setJndiEnvironment("name", "asimov"); + assertEquals("asimov", spds.getJndiEnvironment("name")); + } + + @Test + public void testLoginTimeout() { + spds.setLoginTimeout(10); + assertEquals(10, spds.getLoginTimeout()); + } + + @Test + public void testLogWriterAutoInitialized() { + assertNotNull(spds.getLogWriter()); + } + + @Test + public void testLogWriter() { + spds.setLogWriter(new PrintWriter(System.out)); + assertNotNull(spds.getLogWriter()); + } + + @Test + public void testValidationQuery() { + assertNull(spds.getValidationQuery()); + spds.setValidationQuery("anything"); + assertEquals("anything", spds.getValidationQuery()); + } + + @Test(expected=IllegalStateException.class) + public void testValidationQueryWithConnectionCalled() throws SQLException { + spds.getConnection(); + assertNull(spds.getValidationQuery()); + spds.setValidationQuery("anything"); + } + + @Test + public void testValidationQueryTimeout() { + assertEquals(-1, spds.getValidationQueryTimeout()); + spds.setValidationQueryTimeout(10); + assertEquals(10, spds.getValidationQueryTimeout()); + } + + @Test + public void testRollbackAfterValidation() { + assertFalse(spds.isRollbackAfterValidation()); + spds.setRollbackAfterValidation(true); + assertEquals(true, spds.isRollbackAfterValidation()); + } + + @Test(expected=IllegalStateException.class) + public void testRollbackAfterValidationWithConnectionCalled() throws SQLException { + spds.getConnection(); + assertFalse(spds.isRollbackAfterValidation()); + spds.setRollbackAfterValidation(true); + assertEquals(true, spds.isRollbackAfterValidation()); + } + + @Test + public void testMaxConnLifetimeMillis() { + assertEquals(-1, spds.getMaxConnLifetimeMillis()); + spds.setMaxConnLifetimeMillis(10); + assertEquals(10, spds.getMaxConnLifetimeMillis()); + } + + @Test + public void testDefaultReadOnly() { + spds.setDefaultReadOnly(true); + assertTrue(spds.isDefaultReadOnly()); + spds.setDefaultReadOnly(false); + assertFalse(spds.isDefaultReadOnly()); + } + + @Test + public void testDefaultTestOnCreate() { + spds.setDefaultTestOnCreate(false); + assertFalse(spds.getDefaultTestOnCreate()); + spds.setDefaultTestOnCreate(true); + assertTrue(spds.getDefaultTestOnCreate()); + } + + @Test + public void testDefaultSoftMinEvictableIdleTimeMillis() { + spds.setDefaultSoftMinEvictableIdleTimeMillis(10); + assertEquals(10, spds.getDefaultSoftMinEvictableIdleTimeMillis()); + } + + @Test + public void testDefaultMinIdle() { + spds.setDefaultMinIdle(10); + assertEquals(10, spds.getDefaultMinIdle()); + } + + @Test + public void testDefaultLifo() { + spds.setDefaultLifo(true); + assertTrue(spds.getDefaultLifo()); + spds.setDefaultLifo(false); + assertFalse(spds.getDefaultLifo()); + } + + @Test + public void testDefaultEvictionPolicyClassName() { + spds.setDefaultEvictionPolicyClassName(Object.class.getName()); + assertEquals(Object.class.getName(), spds.getDefaultEvictionPolicyClassName()); + } + + @Test + public void testDefaultBlockWhenExhausted() { + spds.setDefaultBlockWhenExhausted(true); + assertTrue(spds.getDefaultBlockWhenExhausted()); + spds.setDefaultBlockWhenExhausted(false); + assertFalse(spds.getDefaultBlockWhenExhausted()); + } + + @Test + public void testConnection() throws SQLException, ClassNotFoundException { + spds = new SharedPoolDataSource(); + pcds.setDriver(DRIVER); + pcds.setUrl(URL); + spds.setConnectionPoolDataSource(pcds); + PooledConnectionAndInfo info = spds.getPooledConnectionAndInfo(null, null); + assertNull(info.getUsername()); + assertNull(info.getPassword()); + Connection conn = spds.getConnection(); + assertNotNull(conn); + } }
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/datasources/TestPerUserPoolDataSource.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbcp2/datasources/TestPerUserPoolDataSource.java b/src/test/java/org/apache/commons/dbcp2/datasources/TestPerUserPoolDataSource.java index ad4debf..623ccb4 100644 --- a/src/test/java/org/apache/commons/dbcp2/datasources/TestPerUserPoolDataSource.java +++ b/src/test/java/org/apache/commons/dbcp2/datasources/TestPerUserPoolDataSource.java @@ -31,12 +31,15 @@ import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; +import java.util.HashMap; +import java.util.Map; import javax.sql.DataSource; import org.apache.commons.dbcp2.TestConnectionPool; import org.apache.commons.dbcp2.TesterDriver; import org.apache.commons.dbcp2.cpdsadapter.DriverAdapterCPDS; +import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -44,19 +47,22 @@ import org.junit.Test; */ public class TestPerUserPoolDataSource extends TestConnectionPool { + private String user; + @Override protected Connection getConnection() throws SQLException { - return ds.getConnection("foo","bar"); + return ds.getConnection(user,"bar"); } private DataSource ds; @Before public void setUp() throws Exception { + user = "foo"; final DriverAdapterCPDS pcds = new DriverAdapterCPDS(); pcds.setDriver("org.apache.commons.dbcp2.TesterDriver"); pcds.setUrl("jdbc:apache:commons:testdriver"); - pcds.setUser("foo"); + pcds.setUser(user); pcds.setPassword("bar"); pcds.setAccessToUnderlyingConnectionAllowed(true); @@ -64,14 +70,20 @@ public class TestPerUserPoolDataSource extends TestConnectionPool { tds.setConnectionPoolDataSource(pcds); tds.setDefaultMaxTotal(getMaxTotal()); tds.setDefaultMaxWaitMillis((int)getMaxWaitMillis()); - tds.setPerUserMaxTotal("foo", Integer.valueOf(getMaxTotal())); - tds.setPerUserMaxWaitMillis("foo", Long.valueOf(getMaxWaitMillis())); + tds.setPerUserMaxTotal(user, Integer.valueOf(getMaxTotal())); + tds.setPerUserMaxWaitMillis(user, Long.valueOf(getMaxWaitMillis())); tds.setDefaultTransactionIsolation( Connection.TRANSACTION_READ_COMMITTED); tds.setDefaultAutoCommit(Boolean.TRUE); ds = tds; } + @After + public void tearDown() throws Exception { + super.tearDown(); + ((PerUserPoolDataSource) ds).close(); + } + /** * Switching 'u1 to 'u2' and 'p1' to 'p2' will * exhibit the bug detailed in @@ -102,12 +114,12 @@ public class TestPerUserPoolDataSource extends TestConnectionPool { ds.getConnection("u1", "p1").close(); // Try related users and passwords - ds.getConnection("foo", "bar").close(); + ds.getConnection(user, "bar").close(); try (Connection c = ds.getConnection("foob", "ar")) { fail("Should have caused an SQLException"); } catch (final SQLException expected) { } - try (Connection c = ds.getConnection("foo", "baz")){ + try (Connection c = ds.getConnection(user, "baz")){ fail("Should have generated SQLException"); } catch (final SQLException expected) { } @@ -371,7 +383,7 @@ public class TestPerUserPoolDataSource extends TestConnectionPool { // some JVMs, e.g. Windows. final int defaultMaxWaitMillis = 430; ((PerUserPoolDataSource) ds).setDefaultMaxWaitMillis(defaultMaxWaitMillis); - ((PerUserPoolDataSource) ds).setPerUserMaxWaitMillis("foo",new Long(defaultMaxWaitMillis)); + ((PerUserPoolDataSource) ds).setPerUserMaxWaitMillis(user,new Long(defaultMaxWaitMillis)); multipleThreads(1, false, false, defaultMaxWaitMillis); } @@ -379,7 +391,7 @@ public class TestPerUserPoolDataSource extends TestConnectionPool { public void testMultipleThreads2() throws Exception { final int defaultMaxWaitMillis = 500; ((PerUserPoolDataSource) ds).setDefaultMaxWaitMillis(defaultMaxWaitMillis); - ((PerUserPoolDataSource) ds).setPerUserMaxWaitMillis("foo",new Long(defaultMaxWaitMillis)); + ((PerUserPoolDataSource) ds).setPerUserMaxWaitMillis(user,new Long(defaultMaxWaitMillis)); multipleThreads(2 * defaultMaxWaitMillis, true, true, defaultMaxWaitMillis); } @@ -501,37 +513,1128 @@ public class TestPerUserPoolDataSource extends TestConnectionPool { // See DBCP-8 @Test public void testChangePassword() throws Exception { - try (Connection c = ds.getConnection("foo", "bay")){ + try (Connection c = ds.getConnection(user, "bay")){ fail("Should have generated SQLException"); } catch (final SQLException expected) { } - final Connection con1 = ds.getConnection("foo", "bar"); - final Connection con2 = ds.getConnection("foo", "bar"); - final Connection con3 = ds.getConnection("foo", "bar"); + final Connection con1 = ds.getConnection(user, "bar"); + final Connection con2 = ds.getConnection(user, "bar"); + final Connection con3 = ds.getConnection(user, "bar"); con1.close(); con2.close(); - TesterDriver.addUser("foo","bay"); // change the user/password setting + TesterDriver.addUser(user,"bay"); // change the user/password setting try { - final Connection con4 = ds.getConnection("foo", "bay"); // new password + final Connection con4 = ds.getConnection(user, "bay"); // new password // Idle instances with old password should have been cleared assertEquals("Should be no idle connections in the pool", - 0, ((PerUserPoolDataSource) ds).getNumIdle("foo")); + 0, ((PerUserPoolDataSource) ds).getNumIdle(user)); con4.close(); // Should be one idle instance with new pwd assertEquals("Should be one idle connection in the pool", - 1, ((PerUserPoolDataSource) ds).getNumIdle("foo")); - try (Connection c = ds.getConnection("foo", "bar")) { // old password + 1, ((PerUserPoolDataSource) ds).getNumIdle(user)); + try (Connection c = ds.getConnection(user, "bar")) { // old password fail("Should have generated SQLException"); } catch (final SQLException expected) { } - final Connection con5 = ds.getConnection("foo", "bay"); // take the idle one + final Connection con5 = ds.getConnection(user, "bay"); // take the idle one con3.close(); // Return a connection with the old password - ds.getConnection("foo", "bay").close(); // will try bad returned connection and destroy it + ds.getConnection(user, "bay").close(); // will try bad returned connection and destroy it assertEquals("Should be one idle connection in the pool", - 1, ((PerUserPoolDataSource) ds).getNumIdle("foo")); + 1, ((PerUserPoolDataSource) ds).getNumIdle(user)); con5.close(); } finally { - TesterDriver.addUser("foo","bar"); + TesterDriver.addUser(user,"bar"); } } + + // getters and setters. Most follow the same pattern. The initial tests contain a more + // complete documentation, which can be helpful when write/understanding the other methods. + + // -- per user block when exhausted + + /** + * Test per user block when exhausted, with the backing map not initialized before. + * Instead we pass the map. + */ + @Test + public void testPerUserBlockWhenExhaustedMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> userDefaultBlockWhenExhausted = new HashMap<>(); + userDefaultBlockWhenExhausted.put("key", Boolean.TRUE); + ds.setPerUserBlockWhenExhausted(userDefaultBlockWhenExhausted); + assertEquals(Boolean.TRUE, ds.getPerUserBlockWhenExhausted("key")); + } + + /** + * Test per user block when exhausted, with the backing map initialized before. + */ + @Test + public void testPerUserBlockWhenExhaustedMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> userDefaultBlockWhenExhausted = new HashMap<>(); + userDefaultBlockWhenExhausted.put("key", Boolean.FALSE); + ds.setPerUserBlockWhenExhausted(userDefaultBlockWhenExhausted); + assertEquals(Boolean.FALSE, ds.getPerUserBlockWhenExhausted("key")); + // when the code above is executed, the backing map was initalized + // now check if that still works. The backing map is clear'ed. + userDefaultBlockWhenExhausted = new HashMap<>(); + userDefaultBlockWhenExhausted.put("anonymous", Boolean.FALSE); + ds.setPerUserBlockWhenExhausted(userDefaultBlockWhenExhausted); + // now the previously entered value was cleared, so it will be back to the + // default value of TRUE + assertEquals(Boolean.TRUE, ds.getPerUserBlockWhenExhausted("key")); + // and our new value exists too + assertEquals(Boolean.FALSE, ds.getPerUserBlockWhenExhausted("anonymous")); + } + + /** + * Test per user block when exhausted, with the backing map not initialized before. + * Instead, we pass the map. And furthermore, we are now searching for an inexistent + * key, which should return the default value. + */ + @Test + public void testPerUserBlockWhenExhaustedMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> userDefaultBlockWhenExhausted = new HashMap<>(); + userDefaultBlockWhenExhausted.put("key", Boolean.FALSE); + ds.setPerUserBlockWhenExhausted(userDefaultBlockWhenExhausted); + assertEquals(ds.getDefaultBlockWhenExhausted(), ds.getPerUserBlockWhenExhausted("missingkey")); + } + + /** + * Test per user block when exhausted, with the backing map not initialized before. + * Instead we pass the user and value, and hence the map is initialized beforehand. + */ + @Test + public void testPerUserBlockWhenExhaustedWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserBlockWhenExhausted(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserBlockWhenExhausted(user)); + } + + /** + * Test per user block when exhausted, with the backing map not initialized before. + * Instead we pass the user and value, and hence the map is initialized beforehand. + * After that, we pass another user, so both values should still be present. The + * PerUserPoolDataSource does not clear the perUserPoolDataSource map, unless you + * pass a new map, using another internal/package method. + */ + @Test + public void testPerUserBlockWhenExhaustedWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserBlockWhenExhausted(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserBlockWhenExhausted(user)); + // when the code above is executed, the backing map was initalized + // now check if that still works. The backing map is NOT clear'ed. + ds.setPerUserBlockWhenExhausted("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserBlockWhenExhausted(user)); + assertEquals(Boolean.FALSE, ds.getPerUserBlockWhenExhausted("anotheruser")); + } + + /** + * Test per user block when exhausted, with the backing map not initialized before. + * Instead we pass the user and value, and hence the map is initialized beforehand. + * Furthermore, we are now searching for an inexistent key, which should return the + * default value. + */ + @Test + public void testPerUserBlockWhenExhaustedWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserBlockWhenExhausted("whatismyuseragain?", Boolean.FALSE); + assertEquals(Boolean.TRUE, ds.getPerUserBlockWhenExhausted("missingkey")); + } + + // -- per user default auto commit + + @Test + public void testPerUserDefaultAutoCommitMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.TRUE); + ds.setPerUserDefaultAutoCommit(values); + assertEquals(Boolean.TRUE, ds.getPerUserDefaultAutoCommit("key")); + } + + @Test + public void testPerUserDefaultAutoCommitMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserDefaultAutoCommit(values); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultAutoCommit("key")); + values = new HashMap<>(); + values.put("anonymous", Boolean.FALSE); + ds.setPerUserDefaultAutoCommit(values); + assertEquals(null, ds.getPerUserDefaultAutoCommit("key")); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultAutoCommit("anonymous")); + } + + @Test + public void testPerUserDefaultAutoCommitMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserDefaultAutoCommit(values); + // TODO this is not consistent with the other methods + assertEquals(null, ds.getPerUserDefaultAutoCommit("missingkey")); + } + + @Test + public void testPerUserDefaultAutoCommitWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultAutoCommit(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultAutoCommit(user)); + } + + @Test + public void testPerUserDefaultAutoCommitWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultAutoCommit(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultAutoCommit(user)); + ds.setPerUserDefaultAutoCommit("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultAutoCommit(user)); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultAutoCommit("anotheruser")); + } + + @Test + public void testPerUserDefaultAutoCommitWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultAutoCommit("whatismyuseragain?", Boolean.FALSE); + // TODO this is not consistent with the other methods + assertEquals(null, ds.getPerUserDefaultAutoCommit("missingkey")); + } + + // -- per user default read only + + @Test + public void testPerUserDefaultReadOnlyMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.TRUE); + ds.setPerUserDefaultReadOnly(values); + assertEquals(Boolean.TRUE, ds.getPerUserDefaultReadOnly("key")); + } + + @Test + public void testPerUserDefaultReadOnlyMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserDefaultReadOnly(values); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultReadOnly("key")); + values = new HashMap<>(); + values.put("anonymous", Boolean.FALSE); + ds.setPerUserDefaultReadOnly(values); + assertEquals(null, ds.getPerUserDefaultReadOnly("key")); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultReadOnly("anonymous")); + } + + @Test + public void testPerUserDefaultReadOnlyMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserDefaultReadOnly(values); + // TODO this is not consistent with the other methods + assertEquals(null, ds.getPerUserDefaultReadOnly("missingkey")); + } + + @Test + public void testPerUserDefaultReadOnlyWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultReadOnly(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultReadOnly(user)); + } + + @Test + public void testPerUserDefaultReadOnlyWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultReadOnly(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultReadOnly(user)); + ds.setPerUserDefaultReadOnly("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultReadOnly(user)); + assertEquals(Boolean.FALSE, ds.getPerUserDefaultReadOnly("anotheruser")); + } + + @Test + public void testPerUserDefaultReadOnlyWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultReadOnly("whatismyuseragain?", Boolean.FALSE); + // TODO this is not consistent with the other methods + assertEquals(null, ds.getPerUserDefaultReadOnly("missingkey")); + } + + // -- per user default transaction isolation + + @Test + public void testPerUserDefaultTransactionIsolationMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 1); + ds.setPerUserDefaultTransactionIsolation(values); + assertEquals((Integer) 1, (Integer) ds.getPerUserDefaultTransactionIsolation("key")); + } + + @Test + public void testPerUserDefaultTransactionIsolationMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserDefaultTransactionIsolation(values); + assertEquals((Integer) 0, (Integer) ds.getPerUserDefaultTransactionIsolation("key")); + values = new HashMap<>(); + values.put("anonymous", 0); + ds.setPerUserDefaultTransactionIsolation(values); + // TODO this is not consistent with the other methods + assertEquals(null, (Integer) ds.getPerUserDefaultTransactionIsolation("key")); + assertEquals((Integer) 0, (Integer) ds.getPerUserDefaultTransactionIsolation("anonymous")); + } + + @Test + public void testPerUserDefaultTransactionIsolationMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserDefaultTransactionIsolation(values); + // TODO this is not consistent with the other methods + assertEquals(null, (Integer) ds.getPerUserDefaultTransactionIsolation("missingkey")); + } + + @Test + public void testPerUserDefaultTransactionIsolationWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultTransactionIsolation(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserDefaultTransactionIsolation(user)); + } + + @Test + public void testPerUserDefaultTransactionIsolationWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultTransactionIsolation(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserDefaultTransactionIsolation(user)); + ds.setPerUserDefaultTransactionIsolation("anotheruser", 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserDefaultTransactionIsolation(user)); + assertEquals((Integer) 0, (Integer) ds.getPerUserDefaultTransactionIsolation("anotheruser")); + } + + @Test + public void testPerUserDefaultTransactionIsolationWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserDefaultTransactionIsolation("whatismyuseragain?", 0); + // TODO this is not consistent with the other methods + assertEquals(null, (Integer) ds.getPerUserDefaultTransactionIsolation("missingkey")); + } + + // -- per user eviction policy class name + + @Test + public void testPerUserEvictionPolicyClassNameMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, String> values = new HashMap<>(); + values.put("key", "test"); + ds.setPerUserEvictionPolicyClassName(values); + assertEquals("test", ds.getPerUserEvictionPolicyClassName("key")); + } + + @Test + public void testPerUserEvictionPolicyClassNameMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, String> values = new HashMap<>(); + values.put("key", "bar"); + ds.setPerUserEvictionPolicyClassName(values); + assertEquals("bar", ds.getPerUserEvictionPolicyClassName("key")); + values = new HashMap<>(); + values.put("anonymous", "bar"); + ds.setPerUserEvictionPolicyClassName(values); + assertEquals(ds.getDefaultEvictionPolicyClassName(), ds.getPerUserEvictionPolicyClassName("key")); + assertEquals("bar", ds.getPerUserEvictionPolicyClassName("anonymous")); + } + + @Test + public void testPerUserEvictionPolicyClassNameMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, String> values = new HashMap<>(); + values.put("key", "bar"); + ds.setPerUserEvictionPolicyClassName(values); + assertEquals(ds.getDefaultEvictionPolicyClassName(), ds.getPerUserEvictionPolicyClassName("missingkey")); + } + + @Test + public void testPerUserEvictionPolicyClassNameWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserEvictionPolicyClassName(user, "bar"); + assertEquals("bar", ds.getPerUserEvictionPolicyClassName(user)); + } + + @Test + public void testPerUserEvictionPolicyClassNameWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserEvictionPolicyClassName(user, "bar"); + assertEquals("bar", ds.getPerUserEvictionPolicyClassName(user)); + ds.setPerUserEvictionPolicyClassName("anotheruser", "bar"); + assertEquals("bar", ds.getPerUserEvictionPolicyClassName(user)); + assertEquals("bar", ds.getPerUserEvictionPolicyClassName("anotheruser")); + } + + @Test + public void testPerUserEvictionPolicyClassNameWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserEvictionPolicyClassName("whatismyuseragain?", "bar"); + assertEquals(ds.getDefaultEvictionPolicyClassName(), ds.getPerUserEvictionPolicyClassName("missingkey")); + } + + // -- per user lifo + + @Test + public void testPerUserLifoMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.TRUE); + ds.setPerUserLifo(values); + assertEquals(Boolean.TRUE, ds.getPerUserLifo("key")); + } + + @Test + public void testPerUserLifoMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserLifo(values); + assertEquals(Boolean.FALSE, ds.getPerUserLifo("key")); + values = new HashMap<>(); + values.put("anonymous", Boolean.FALSE); + ds.setPerUserLifo(values); + assertEquals(ds.getDefaultLifo(), ds.getPerUserLifo("key")); + assertEquals(Boolean.FALSE, ds.getPerUserLifo("anonymous")); + } + + @Test + public void testPerUserLifoMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserLifo(values); + assertEquals(ds.getDefaultLifo(), ds.getPerUserLifo("missingkey")); + } + + @Test + public void testPerUserLifoWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserLifo(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserLifo(user)); + } + + @Test + public void testPerUserLifoWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserLifo(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserLifo(user)); + ds.setPerUserLifo("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserLifo(user)); + assertEquals(Boolean.FALSE, ds.getPerUserLifo("anotheruser")); + } + + @Test + public void testPerUserLifoWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserLifo("whatismyuseragain?", Boolean.FALSE); + assertEquals(ds.getDefaultLifo(), ds.getPerUserLifo("missingkey")); + } + + // -- per user max idle + + @Test + public void testPerUserMaxIdleMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 1); + ds.setPerUserMaxIdle(values); + assertEquals((Integer) 1, (Integer) ds.getPerUserMaxIdle("key")); + } + + @Test + public void testPerUserMaxIdleMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserMaxIdle(values); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxIdle("key")); + values = new HashMap<>(); + values.put("anonymous", 0); + ds.setPerUserMaxIdle(values); + assertEquals((Integer) ds.getDefaultMaxIdle(), (Integer) ds.getPerUserMaxIdle("key")); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxIdle("anonymous")); + } + + @Test + public void testPerUserMaxIdleMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserMaxIdle(values); + assertEquals((Integer) ds.getDefaultMaxIdle(), (Integer) ds.getPerUserMaxIdle("missingkey")); + } + + @Test + public void testPerUserMaxIdleWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxIdle(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxIdle(user)); + } + + @Test + public void testPerUserMaxIdleWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxIdle(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxIdle(user)); + ds.setPerUserMaxIdle("anotheruser", 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxIdle(user)); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxIdle("anotheruser")); + } + + @Test + public void testPerUserMaxIdleWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxIdle("whatismyuseragain?", 0); + assertEquals((Integer) ds.getDefaultMaxIdle(), (Integer) ds.getPerUserMaxIdle("missingkey")); + } + + // -- per user max total + + @Test + public void testPerUserMaxTotalMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 1); + ds.setPerUserMaxTotal(values); + assertEquals((Integer) 1, (Integer) ds.getPerUserMaxTotal("key")); + } + + @Test + public void testPerUserMaxTotalMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserMaxTotal(values); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxTotal("key")); + values = new HashMap<>(); + values.put("anonymous", 0); + ds.setPerUserMaxTotal(values); + assertEquals((Integer) ds.getDefaultMaxTotal(), (Integer) ds.getPerUserMaxTotal("key")); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxTotal("anonymous")); + } + + @Test + public void testPerUserMaxTotalMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserMaxTotal(values); + assertEquals((Integer) ds.getDefaultMaxTotal(), (Integer) ds.getPerUserMaxTotal("missingkey")); + } + + @Test + public void testPerUserMaxTotalWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxTotal(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxTotal(user)); + } + + @Test + public void testPerUserMaxTotalWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxTotal(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxTotal(user)); + ds.setPerUserMaxTotal("anotheruser", 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxTotal(user)); + assertEquals((Integer) 0, (Integer) ds.getPerUserMaxTotal("anotheruser")); + } + + @Test + public void testPerUserMaxTotalWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxTotal("whatismyuseragain?", 0); + assertEquals((Integer) ds.getDefaultMaxTotal(), (Integer) ds.getPerUserMaxTotal("missingkey")); + } + + // -- per user max wait millis + + @Test + public void testPerUserMaxWaitMillisMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 1l); + ds.setPerUserMaxWaitMillis(values); + assertEquals(1l, ds.getPerUserMaxWaitMillis("key")); + } + + @Test + public void testPerUserMaxWaitMillisMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserMaxWaitMillis(values); + assertEquals(0l, ds.getPerUserMaxWaitMillis("key")); + values = new HashMap<>(); + values.put("anonymous", 0l); + ds.setPerUserMaxWaitMillis(values); + assertEquals(ds.getDefaultMaxWaitMillis(), ds.getPerUserMaxWaitMillis("key")); + assertEquals(0l, ds.getPerUserMaxWaitMillis("anonymous")); + } + + @Test + public void testPerUserMaxWaitMillisMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserMaxWaitMillis(values); + assertEquals(ds.getDefaultMaxWaitMillis(), ds.getPerUserMaxWaitMillis("missingkey")); + } + + @Test + public void testPerUserMaxWaitMillisWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxWaitMillis(user, 0l); + assertEquals(0l, ds.getPerUserMaxWaitMillis(user)); + } + + @Test + public void testPerUserMaxWaitMillisWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxWaitMillis(user, 0l); + assertEquals(0l, ds.getPerUserMaxWaitMillis(user)); + ds.setPerUserMaxWaitMillis("anotheruser", 0l); + assertEquals(0l, ds.getPerUserMaxWaitMillis(user)); + assertEquals(0l, ds.getPerUserMaxWaitMillis("anotheruser")); + } + + @Test + public void testPerUserMaxWaitMillisWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMaxWaitMillis("whatismyuseragain?", 0l); + assertEquals(ds.getDefaultMaxWaitMillis(), ds.getPerUserMaxWaitMillis("missingkey")); + } + + // -- per user min evictable idle time millis + + @Test + public void testPerUserMinEvictableIdleTimeMillisMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 1l); + ds.setPerUserMinEvictableIdleTimeMillis(values); + assertEquals(1l, ds.getPerUserMinEvictableIdleTimeMillis("key")); + } + + @Test + public void testPerUserMinEvictableIdleTimeMillisMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserMinEvictableIdleTimeMillis(values); + assertEquals(0l, ds.getPerUserMinEvictableIdleTimeMillis("key")); + values = new HashMap<>(); + values.put("anonymous", 0l); + ds.setPerUserMinEvictableIdleTimeMillis(values); + assertEquals(ds.getDefaultMinEvictableIdleTimeMillis(), ds.getPerUserMinEvictableIdleTimeMillis("key")); + assertEquals(0l, ds.getPerUserMinEvictableIdleTimeMillis("anonymous")); + } + + @Test + public void testPerUserMinEvictableIdleTimeMillisMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserMinEvictableIdleTimeMillis(values); + assertEquals(ds.getDefaultMinEvictableIdleTimeMillis(), ds.getPerUserMinEvictableIdleTimeMillis("missingkey")); + } + + @Test + public void testPerUserMinEvictableIdleTimeMillisWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMinEvictableIdleTimeMillis(user, 0l); + assertEquals(0l, ds.getPerUserMinEvictableIdleTimeMillis(user)); + } + + @Test + public void testPerUserMinEvictableIdleTimeMillisWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMinEvictableIdleTimeMillis(user, 0l); + assertEquals(0l, ds.getPerUserMinEvictableIdleTimeMillis(user)); + ds.setPerUserMinEvictableIdleTimeMillis("anotheruser", 0l); + assertEquals(0l, ds.getPerUserMinEvictableIdleTimeMillis(user)); + assertEquals(0l, ds.getPerUserMinEvictableIdleTimeMillis("anotheruser")); + } + + @Test + public void testPerUserMinEvictableIdleTimeMillisWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMinEvictableIdleTimeMillis("whatismyuseragain?", 0l); + assertEquals(ds.getDefaultMinEvictableIdleTimeMillis(), ds.getPerUserMinEvictableIdleTimeMillis("missingkey")); + } + + // -- per user min idle + + @Test + public void testPerUserMinIdleMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 1); + ds.setPerUserMinIdle(values); + assertEquals((Integer) 1, (Integer) ds.getPerUserMinIdle("key")); + } + + @Test + public void testPerUserMinIdleMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserMinIdle(values); + assertEquals((Integer) 0, (Integer) ds.getPerUserMinIdle("key")); + values = new HashMap<>(); + values.put("anonymous", 0); + ds.setPerUserMinIdle(values); + assertEquals((Integer) ds.getDefaultMinIdle(), (Integer) ds.getPerUserMinIdle("key")); + assertEquals((Integer) 0, (Integer) ds.getPerUserMinIdle("anonymous")); + } + + @Test + public void testPerUserMinIdleMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserMinIdle(values); + assertEquals((Integer) ds.getDefaultMinIdle(), (Integer) ds.getPerUserMinIdle("missingkey")); + } + + @Test + public void testPerUserMinIdleWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMinIdle(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMinIdle(user)); + } + + @Test + public void testPerUserMinIdleWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMinIdle(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMinIdle(user)); + ds.setPerUserMinIdle("anotheruser", 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserMinIdle(user)); + assertEquals((Integer) 0, (Integer) ds.getPerUserMinIdle("anotheruser")); + } + + @Test + public void testPerUserMinIdleWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserMinIdle("whatismyuseragain?", 0); + assertEquals((Integer) ds.getDefaultMinIdle(), (Integer) ds.getPerUserMinIdle("missingkey")); + } + + // -- per user num tests per eviction run + + @Test + public void testPerUserNumTestsPerEvictionRunMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 1); + ds.setPerUserNumTestsPerEvictionRun(values); + assertEquals((Integer) 1, (Integer) ds.getPerUserNumTestsPerEvictionRun("key")); + } + + @Test + public void testPerUserNumTestsPerEvictionRunMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserNumTestsPerEvictionRun(values); + assertEquals((Integer) 0, (Integer) ds.getPerUserNumTestsPerEvictionRun("key")); + values = new HashMap<>(); + values.put("anonymous", 0); + ds.setPerUserNumTestsPerEvictionRun(values); + assertEquals((Integer) ds.getDefaultNumTestsPerEvictionRun(), (Integer) ds.getPerUserNumTestsPerEvictionRun("key")); + assertEquals((Integer) 0, (Integer) ds.getPerUserNumTestsPerEvictionRun("anonymous")); + } + + @Test + public void testPerUserNumTestsPerEvictionRunMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Integer> values = new HashMap<>(); + values.put("key", 0); + ds.setPerUserNumTestsPerEvictionRun(values); + assertEquals((Integer) ds.getDefaultNumTestsPerEvictionRun(), (Integer) ds.getPerUserNumTestsPerEvictionRun("missingkey")); + } + + @Test + public void testPerUserNumTestsPerEvictionRunWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserNumTestsPerEvictionRun(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserNumTestsPerEvictionRun(user)); + } + + @Test + public void testPerUserNumTestsPerEvictionRunWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserNumTestsPerEvictionRun(user, 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserNumTestsPerEvictionRun(user)); + ds.setPerUserNumTestsPerEvictionRun("anotheruser", 0); + assertEquals((Integer) 0, (Integer) ds.getPerUserNumTestsPerEvictionRun(user)); + assertEquals((Integer) 0, (Integer) ds.getPerUserNumTestsPerEvictionRun("anotheruser")); + } + + @Test + public void testPerUserNumTestsPerEvictionRunWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserNumTestsPerEvictionRun("whatismyuseragain?", 0); + assertEquals((Integer) ds.getDefaultNumTestsPerEvictionRun(), (Integer) ds.getPerUserNumTestsPerEvictionRun("missingkey")); + } + + // -- per user soft min evictable idle time millis + + @Test + public void testPerUserSoftMinEvictableIdleTimeMillisMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 1l); + ds.setPerUserSoftMinEvictableIdleTimeMillis(values); + assertEquals(1l, ds.getPerUserSoftMinEvictableIdleTimeMillis("key")); + } + + @Test + public void testPerUserSoftMinEvictableIdleTimeMillisMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserSoftMinEvictableIdleTimeMillis(values); + assertEquals(0l, ds.getPerUserSoftMinEvictableIdleTimeMillis("key")); + values = new HashMap<>(); + values.put("anonymous", 0l); + ds.setPerUserSoftMinEvictableIdleTimeMillis(values); + assertEquals(ds.getDefaultSoftMinEvictableIdleTimeMillis(), ds.getPerUserSoftMinEvictableIdleTimeMillis("key")); + assertEquals(0l, ds.getPerUserSoftMinEvictableIdleTimeMillis("anonymous")); + } + + @Test + public void testPerUserSoftMinEvictableIdleTimeMillisMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserSoftMinEvictableIdleTimeMillis(values); + assertEquals(ds.getDefaultSoftMinEvictableIdleTimeMillis(), ds.getPerUserSoftMinEvictableIdleTimeMillis("missingkey")); + } + + @Test + public void testPerUserSoftMinEvictableIdleTimeMillisWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserSoftMinEvictableIdleTimeMillis(user, 0l); + assertEquals(0l, ds.getPerUserSoftMinEvictableIdleTimeMillis(user)); + } + + @Test + public void testPerUserSoftMinEvictableIdleTimeMillisWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserSoftMinEvictableIdleTimeMillis(user, 0l); + assertEquals(0l, ds.getPerUserSoftMinEvictableIdleTimeMillis(user)); + ds.setPerUserSoftMinEvictableIdleTimeMillis("anotheruser", 0l); + assertEquals(0l, ds.getPerUserSoftMinEvictableIdleTimeMillis(user)); + assertEquals(0l, ds.getPerUserSoftMinEvictableIdleTimeMillis("anotheruser")); + } + + @Test + public void testPerUserSoftMinEvictableIdleTimeMillisWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserSoftMinEvictableIdleTimeMillis("whatismyuseragain?", 0l); + assertEquals(ds.getDefaultSoftMinEvictableIdleTimeMillis(), ds.getPerUserSoftMinEvictableIdleTimeMillis("missingkey")); + } + + // -- per user test on borrow + + @Test + public void testPerUserTestOnBorrowMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.TRUE); + ds.setPerUserTestOnBorrow(values); + assertEquals(Boolean.TRUE, ds.getPerUserTestOnBorrow("key")); + } + + @Test + public void testPerUserTestOnBorrowMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestOnBorrow(values); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnBorrow("key")); + values = new HashMap<>(); + values.put("anonymous", Boolean.FALSE); + ds.setPerUserTestOnBorrow(values); + assertEquals(ds.getDefaultTestOnBorrow(), ds.getPerUserTestOnBorrow("key")); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnBorrow("anonymous")); + } + + @Test + public void testPerUserTestOnBorrowMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestOnBorrow(values); + assertEquals(ds.getDefaultTestOnBorrow(), ds.getPerUserTestOnBorrow("missingkey")); + } + + @Test + public void testPerUserTestOnBorrowWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnBorrow(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnBorrow(user)); + } + + @Test + public void testPerUserTestOnBorrowWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnBorrow(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnBorrow(user)); + ds.setPerUserTestOnBorrow("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnBorrow(user)); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnBorrow("anotheruser")); + } + + @Test + public void testPerUserTestOnBorrowWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnBorrow("whatismyuseragain?", Boolean.FALSE); + assertEquals(ds.getDefaultTestOnBorrow(), ds.getPerUserTestOnBorrow("missingkey")); + } + + // -- per user test on create + + @Test + public void testPerUserTestOnCreateMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.TRUE); + ds.setPerUserTestOnCreate(values); + assertEquals(Boolean.TRUE, ds.getPerUserTestOnCreate("key")); + } + + @Test + public void testPerUserTestOnCreateMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestOnCreate(values); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnCreate("key")); + values = new HashMap<>(); + values.put("anonymous", Boolean.FALSE); + ds.setPerUserTestOnCreate(values); + assertEquals(ds.getDefaultTestOnCreate(), ds.getPerUserTestOnCreate("key")); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnCreate("anonymous")); + } + + @Test + public void testPerUserTestOnCreateMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestOnCreate(values); + assertEquals(ds.getDefaultTestOnCreate(), ds.getPerUserTestOnCreate("missingkey")); + } + + @Test + public void testPerUserTestOnCreateWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnCreate(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnCreate(user)); + } + + @Test + public void testPerUserTestOnCreateWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnCreate(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnCreate(user)); + ds.setPerUserTestOnCreate("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnCreate(user)); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnCreate("anotheruser")); + } + + @Test + public void testPerUserTestOnCreateWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnCreate("whatismyuseragain?", Boolean.FALSE); + assertEquals(ds.getDefaultTestOnCreate(), ds.getPerUserTestOnCreate("missingkey")); + } + + // -- per user test on return + + @Test + public void testPerUserTestOnReturnMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.TRUE); + ds.setPerUserTestOnReturn(values); + assertEquals(Boolean.TRUE, ds.getPerUserTestOnReturn("key")); + } + + @Test + public void testPerUserTestOnReturnMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestOnReturn(values); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnReturn("key")); + values = new HashMap<>(); + values.put("anonymous", Boolean.FALSE); + ds.setPerUserTestOnReturn(values); + assertEquals(ds.getDefaultTestOnReturn(), ds.getPerUserTestOnReturn("key")); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnReturn("anonymous")); + } + + @Test + public void testPerUserTestOnReturnMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestOnReturn(values); + assertEquals(ds.getDefaultTestOnReturn(), ds.getPerUserTestOnReturn("missingkey")); + } + + @Test + public void testPerUserTestOnReturnWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnReturn(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnReturn(user)); + } + + @Test + public void testPerUserTestOnReturnWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnReturn(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnReturn(user)); + ds.setPerUserTestOnReturn("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnReturn(user)); + assertEquals(Boolean.FALSE, ds.getPerUserTestOnReturn("anotheruser")); + } + + @Test + public void testPerUserTestOnReturnWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestOnReturn("whatismyuseragain?", Boolean.FALSE); + assertEquals(ds.getDefaultTestOnReturn(), ds.getPerUserTestOnReturn("missingkey")); + } + + // -- per user test while idle + + @Test + public void testPerUserTestWhileIdleMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.TRUE); + ds.setPerUserTestWhileIdle(values); + assertEquals(Boolean.TRUE, ds.getPerUserTestWhileIdle("key")); + } + + @Test + public void testPerUserTestWhileIdleMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestWhileIdle(values); + assertEquals(Boolean.FALSE, ds.getPerUserTestWhileIdle("key")); + values = new HashMap<>(); + values.put("anonymous", Boolean.FALSE); + ds.setPerUserTestWhileIdle(values); + assertEquals(ds.getDefaultTestWhileIdle(), ds.getPerUserTestWhileIdle("key")); + assertEquals(Boolean.FALSE, ds.getPerUserTestWhileIdle("anonymous")); + } + + @Test + public void testPerUserTestWhileIdleMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Boolean> values = new HashMap<>(); + values.put("key", Boolean.FALSE); + ds.setPerUserTestWhileIdle(values); + assertEquals(ds.getDefaultTestWhileIdle(), ds.getPerUserTestWhileIdle("missingkey")); + } + + @Test + public void testPerUserTestWhileIdleWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestWhileIdle(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestWhileIdle(user)); + } + + @Test + public void testPerUserTestWhileIdleWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestWhileIdle(user, Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestWhileIdle(user)); + ds.setPerUserTestWhileIdle("anotheruser", Boolean.FALSE); + assertEquals(Boolean.FALSE, ds.getPerUserTestWhileIdle(user)); + assertEquals(Boolean.FALSE, ds.getPerUserTestWhileIdle("anotheruser")); + } + + @Test + public void testPerUserTestWhileIdleWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTestWhileIdle("whatismyuseragain?", Boolean.FALSE); + assertEquals(ds.getDefaultTestWhileIdle(), ds.getPerUserTestWhileIdle("missingkey")); + } + + // -- per user time between eviction runs millis + + @Test + public void testPerUserTimeBetweenEvictionRunsMillisMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 1l); + ds.setPerUserTimeBetweenEvictionRunsMillis(values); + assertEquals(1l, ds.getPerUserTimeBetweenEvictionRunsMillis("key")); + } + + @Test + public void testPerUserTimeBetweenEvictionRunsMillisMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserTimeBetweenEvictionRunsMillis(values); + assertEquals(0l, ds.getPerUserTimeBetweenEvictionRunsMillis("key")); + values = new HashMap<>(); + values.put("anonymous", 0l); + ds.setPerUserTimeBetweenEvictionRunsMillis(values); + assertEquals(ds.getDefaultTimeBetweenEvictionRunsMillis(), ds.getPerUserTimeBetweenEvictionRunsMillis("key")); + assertEquals(0l, ds.getPerUserTimeBetweenEvictionRunsMillis("anonymous")); + } + + @Test + public void testPerUserTimeBetweenEvictionRunsMillisMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + Map<String, Long> values = new HashMap<>(); + values.put("key", 0l); + ds.setPerUserTimeBetweenEvictionRunsMillis(values); + assertEquals(ds.getDefaultTimeBetweenEvictionRunsMillis(), ds.getPerUserTimeBetweenEvictionRunsMillis("missingkey")); + } + + @Test + public void testPerUserTimeBetweenEvictionRunsMillisWithUserMapNotInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTimeBetweenEvictionRunsMillis(user, 0l); + assertEquals(0l, ds.getPerUserTimeBetweenEvictionRunsMillis(user)); + } + + @Test + public void testPerUserTimeBetweenEvictionRunsMillisWithUserMapInitialized() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTimeBetweenEvictionRunsMillis(user, 0l); + assertEquals(0l, ds.getPerUserTimeBetweenEvictionRunsMillis(user)); + ds.setPerUserTimeBetweenEvictionRunsMillis("anotheruser", 0l); + assertEquals(0l, ds.getPerUserTimeBetweenEvictionRunsMillis(user)); + assertEquals(0l, ds.getPerUserTimeBetweenEvictionRunsMillis("anotheruser")); + } + + @Test + public void testPerUserTimeBetweenEvictionRunsMillisWithUserMapNotInitializedMissingKey() { + PerUserPoolDataSource ds = (PerUserPoolDataSource) this.ds; + ds.setPerUserTimeBetweenEvictionRunsMillis("whatismyuseragain?", 0l); + assertEquals(ds.getDefaultTimeBetweenEvictionRunsMillis(), ds.getPerUserTimeBetweenEvictionRunsMillis("missingkey")); + } + } http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/datasources/TestPoolKey.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbcp2/datasources/TestPoolKey.java b/src/test/java/org/apache/commons/dbcp2/datasources/TestPoolKey.java new file mode 100644 index 0000000..5df7809 --- /dev/null +++ b/src/test/java/org/apache/commons/dbcp2/datasources/TestPoolKey.java @@ -0,0 +1,65 @@ +/* + * 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.commons.dbcp2.datasources; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; + +import org.junit.Before; +import org.junit.Test; + +/** + * Tests for PoolKey. + * @since 2.5.0 + */ +public class TestPoolKey { + + private PoolKey poolKey; + private PoolKey anotherPoolKey; + + @Before + public void setUp() { + poolKey = new PoolKey("ds", "user"); + anotherPoolKey = new PoolKey(null, null); + } + + @Test + public void testEquals() { + assertEquals(poolKey, poolKey); + assertNotEquals(poolKey, null); + assertNotEquals(poolKey, new Object()); + assertNotEquals(new PoolKey(null, "user"), poolKey); + assertEquals(new PoolKey(null, "user"), new PoolKey(null, "user")); + assertNotEquals(new PoolKey(null, "user"), new PoolKey(null, "foo")); + assertNotEquals(new PoolKey("ds", null), new PoolKey("foo", null)); + assertNotEquals(new PoolKey("ds", null), poolKey); + assertEquals(new PoolKey("ds", null), new PoolKey("ds", null)); + } + + @Test + public void testHashcode() { + assertEquals(poolKey.hashCode(), new PoolKey("ds", "user").hashCode()); + assertNotEquals(poolKey.hashCode(), anotherPoolKey.hashCode()); + } + + @Test + public void testToString() { + assertEquals(poolKey.toString(), new PoolKey("ds", "user").toString()); + assertNotEquals(poolKey.toString(), anotherPoolKey.toString()); + } +} http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/datasources/TestUserPassKey.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbcp2/datasources/TestUserPassKey.java b/src/test/java/org/apache/commons/dbcp2/datasources/TestUserPassKey.java new file mode 100644 index 0000000..b5fb453 --- /dev/null +++ b/src/test/java/org/apache/commons/dbcp2/datasources/TestUserPassKey.java @@ -0,0 +1,74 @@ +/* + * 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.commons.dbcp2.datasources; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; + +import org.apache.commons.dbcp2.Utils; +import org.junit.Before; +import org.junit.Test; + +/** + * Tests for UserPassKey. + * @since 2.5.0 + */ +public class TestUserPassKey { + + private UserPassKey userPassKey; + private UserPassKey anotherUserPassKey; + + @Before + public void setUp() { + userPassKey = new UserPassKey("user", "pass"); + anotherUserPassKey = new UserPassKey((String) null, ""); + } + + @Test + public void testGettersAndSetters() { + assertEquals("user", userPassKey.getUsername()); + assertEquals("pass", userPassKey.getPassword()); + assertTrue(Arrays.equals(Utils.toCharArray("pass"), userPassKey.getPasswordCharArray())); + } + + @Test + public void testEquals() { + assertEquals(new UserPassKey("user"), new UserPassKey("user", (char[]) null)); + assertEquals(userPassKey, userPassKey); + assertNotEquals(userPassKey, null); + assertNotEquals(userPassKey, new Object()); + assertNotEquals(new UserPassKey(null), userPassKey); + assertEquals(new UserPassKey(null), new UserPassKey(null)); + assertNotEquals(new UserPassKey("user", "pass"), new UserPassKey("foo", "pass")); + } + + @Test + public void testHashcode() { + assertEquals(userPassKey.hashCode(), new UserPassKey("user", "pass").hashCode()); + assertNotEquals(userPassKey.hashCode(), anotherUserPassKey.hashCode()); + } + + @Test + public void testToString() { + assertEquals(userPassKey.toString(), new UserPassKey("user", "pass").toString()); + assertNotEquals(userPassKey.toString(), anotherUserPassKey.toString()); + } +} http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/managed/TestBasicManagedDataSource.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbcp2/managed/TestBasicManagedDataSource.java b/src/test/java/org/apache/commons/dbcp2/managed/TestBasicManagedDataSource.java index 7ece885..370158e 100644 --- a/src/test/java/org/apache/commons/dbcp2/managed/TestBasicManagedDataSource.java +++ b/src/test/java/org/apache/commons/dbcp2/managed/TestBasicManagedDataSource.java @@ -17,14 +17,21 @@ */ package org.apache.commons.dbcp2.managed; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.fail; import java.sql.SQLException; +import javax.sql.XADataSource; +import javax.transaction.xa.XAException; + import org.apache.commons.dbcp2.BasicDataSource; import org.apache.commons.dbcp2.TestBasicDataSource; import org.apache.geronimo.transaction.manager.TransactionManagerImpl; +import org.h2.Driver; +import org.h2.jdbcx.JdbcDataSource; import org.junit.Test; /** @@ -68,4 +75,100 @@ public class TestBasicManagedDataSource extends TestBasicDataSource { conn2.close(); basicManagedDataSource.close(); } + + @Test + public void testXADataSource() throws SQLException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.setXADataSource("anything"); + assertEquals("anything", basicManagedDataSource.getXADataSource()); + } + } + + @Test + public void testXaDataSourceInstance() throws SQLException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + XADataSource ds = new JdbcDataSource(); + basicManagedDataSource.setXaDataSourceInstance(ds); + assertEquals(ds, basicManagedDataSource.getXaDataSourceInstance()); + } + } + + @Test(expected=SQLException.class) + public void testTransactionManagerNotSet() throws SQLException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.createConnectionFactory(); + } + } + + @Test + public void testSetDriverName() throws SQLException, XAException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.setDriverClassName("adams"); + assertEquals("adams", basicManagedDataSource.getDriverClassName()); + basicManagedDataSource.setDriverClassName(null); + assertNull(basicManagedDataSource.getDriverClassName()); + } + } + + @Test + public void testCreateXaDataSourceNewInstance() throws SQLException, XAException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.setXADataSource(JdbcDataSource.class.getCanonicalName()); + basicManagedDataSource.setDriverClassName(Driver.class.getName()); + basicManagedDataSource.setTransactionManager(new TransactionManagerImpl()); + assertNotNull(basicManagedDataSource.createConnectionFactory()); + } + } + + @Test + public void testCreateXaDataSourceNoInstanceSetAndNoDataSource() throws SQLException, XAException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.setDriverClassName("org.apache.commons.dbcp2.TesterDriver"); + basicManagedDataSource.setUrl("jdbc:apache:commons:testdriver"); + basicManagedDataSource.setTransactionManager(new TransactionManagerImpl()); + assertNotNull(basicManagedDataSource.createConnectionFactory()); + } + } + + @Test(expected=NullPointerException.class) + public void testRuntimeExceptionsAreRethrown() throws SQLException, XAException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.setTransactionManager(new TransactionManagerImpl()); + basicManagedDataSource.setDriverClassName("org.apache.commons.dbcp2.TesterDriver"); + basicManagedDataSource.setUrl("jdbc:apache:commons:testdriver"); + basicManagedDataSource.setUsername("userName"); + basicManagedDataSource.setPassword("password"); + basicManagedDataSource.setMaxIdle(1); + // results in a NPE + basicManagedDataSource.createPoolableConnectionFactory(null); + } + } + + @Test + public void testSetXaDataSourceInstance() throws SQLException, XAException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.setTransactionManager(new TransactionManagerImpl()); + basicManagedDataSource.setDriverClassName("org.apache.commons.dbcp2.TesterDriver"); + basicManagedDataSource.setUrl("jdbc:apache:commons:testdriver"); + basicManagedDataSource.setUsername("userName"); + basicManagedDataSource.setPassword("password"); + basicManagedDataSource.setMaxIdle(1); + basicManagedDataSource.setXaDataSourceInstance(new JdbcDataSource()); + assertNotNull(basicManagedDataSource.createConnectionFactory()); + } + } + + @Test + public void testSetNullXaDataSourceInstance() throws SQLException, XAException { + try (final BasicManagedDataSource basicManagedDataSource = new BasicManagedDataSource()) { + basicManagedDataSource.setTransactionManager(new TransactionManagerImpl()); + basicManagedDataSource.setDriverClassName("org.apache.commons.dbcp2.TesterDriver"); + basicManagedDataSource.setUrl("jdbc:apache:commons:testdriver"); + basicManagedDataSource.setUsername("userName"); + basicManagedDataSource.setPassword("password"); + basicManagedDataSource.setMaxIdle(1); + basicManagedDataSource.setXaDataSourceInstance(null); + assertNull(basicManagedDataSource.getXaDataSourceInstance()); + } + } }