/** * Closing a connection handle should release that connection back in the pool and mark it as * closed. * * @throws SecurityException * @throws NoSuchFieldException * @throws IllegalArgumentException * @throws IllegalAccessException * @throws InvocationTargetException * @throws NoSuchMethodException * @throws SQLException */ @SuppressWarnings("unchecked") @Test public void testInternalClose() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, SQLException { ConcurrentLinkedQueue<Statement> mockStatementHandles = createNiceMock(ConcurrentLinkedQueue.class); StatementHandle mockStatement = createNiceMock(StatementHandle.class); mockConnection.close(); expectLastCall().once().andThrow(new SQLException()).once(); Map<Connection, Reference<ConnectionHandle>> refs = new HashMap<Connection, Reference<ConnectionHandle>>(); expect(mockPool.getFinalizableRefs()).andReturn(refs).anyTimes(); FinalizableReferenceQueue finalizableRefQueue = new FinalizableReferenceQueue(); expect(mockPool.getFinalizableRefQueue()).andReturn(finalizableRefQueue).anyTimes(); expect(mockConnection.getPool()).andReturn(mockPool).anyTimes(); replay(mockStatement, mockConnection, mockStatementHandles, mockPool); testClass.internalClose(); try { testClass.internalClose(); // 2nd time should throw exception fail("Should have thrown an exception"); } catch (Throwable t) { // do nothing. } verify(mockStatement, mockConnection, mockStatementHandles); }
/** * Tests that a partition with expired connections should those connections killed off. * * @throws SQLException */ @Test @SuppressWarnings({"unchecked", "rawtypes"}) public void testConnectionExpired() throws SQLException { TransferQueue<ConnectionHandle> mockQueue = createNiceMock(TransferQueue.class); expect(mockConnectionPartition.getAvailableConnections()).andReturn(1); expect(mockConnectionPartition.getFreeConnections()).andReturn(mockQueue).anyTimes(); ConnectionHandle mockConnectionExpired = createNiceMock(ConnectionHandle.class); ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class); expect(mockQueue.poll()).andReturn(mockConnectionExpired).once(); expect(mockConnectionExpired.isExpired(anyLong())).andReturn(true).once(); expect(mockExecutor.isShutdown()).andReturn(false).once(); mockConnectionExpired.internalClose(); expectLastCall().once(); mockPool.postDestroyConnection(mockConnectionExpired); expectLastCall().once(); expect(mockExecutor.schedule((Callable) anyObject(), anyLong(), (TimeUnit) anyObject())) .andReturn(null) .once(); replay( mockQueue, mockExecutor, mockConnectionPartition, mockConnection, mockPool, mockConnectionExpired); testClass.run(); verify(mockConnectionExpired); }
/** * Tests that a partition with expired connections should those connections killed off. * * @throws SQLException */ @Test @SuppressWarnings("unchecked") public void testConnectionNotExpiredLifoMode() throws SQLException { LIFOQueue<ConnectionHandle> mockQueue = createNiceMock(LIFOQueue.class); expect(mockConnectionPartition.getAvailableConnections()).andReturn(1); expect(mockConnectionPartition.getFreeConnections()).andReturn(mockQueue).anyTimes(); ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class); expect(mockQueue.poll()).andReturn(mockConnection).once(); expect(mockConnection.isExpired(anyLong())).andReturn(false).once(); expect(mockExecutor.isShutdown()).andReturn(false).once(); expect(mockConnection.getOriginatingPartition()).andReturn(mockConnectionPartition).anyTimes(); expect(mockQueue.offerLast(mockConnection)).andReturn(false).anyTimes(); mockConnection.internalClose(); replay(mockQueue, mockExecutor, mockConnectionPartition, mockConnection, mockPool); ConnectionMaxAgeThread testClass2 = new ConnectionMaxAgeThread(mockConnectionPartition, mockExecutor, mockPool, 5000, true); testClass2.run(); verify(mockConnection, mockPool); }
/** * Tests fake exceptions, connection should be shutdown if the scheduler was marked as going down. * Same test except just used to check for a spurious interrupted exception (should be logged). * * @throws SQLException * @throws InterruptedException * @throws NoSuchFieldException * @throws SecurityException * @throws IllegalAccessException * @throws IllegalArgumentException */ @Test public void testExceptionOnCloseConnection() throws SQLException, InterruptedException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException { ArrayBlockingQueue<ConnectionHandle> fakeFreeConnections = new ArrayBlockingQueue<ConnectionHandle>(1); fakeFreeConnections.add(mockConnection); config.setIdleConnectionTestPeriod(1); expect(mockPool.getConfig()).andReturn(config).anyTimes(); expect(mockConnectionPartition.getFreeConnections()).andReturn(fakeFreeConnections).anyTimes(); expect(mockConnectionPartition.getMinConnections()).andReturn(10).once(); expect(mockConnection.isPossiblyBroken()).andReturn(false); expect(mockConnection.getConnectionLastUsed()).andReturn(0L); expect(mockPool.isConnectionHandleAlive((ConnectionHandle) anyObject())) .andReturn(false) .anyTimes(); // connection should be closed mockConnection.internalClose(); expectLastCall().andThrow(new SQLException()); replay(mockPool, mockConnection, mockConnectionPartition, mockExecutor, mockLogger); this.testClass = new ConnectionTesterThread(mockConnectionPartition, mockExecutor, mockPool); Field loggerField = this.testClass.getClass().getDeclaredField("logger"); loggerField.setAccessible(true); loggerField.set(this.testClass, mockLogger); this.testClass.run(); verify(mockPool, mockConnectionPartition, mockExecutor, mockConnection, mockLogger); }
/** * Tests fake exceptions, connection should be shutdown if the scheduler was marked as going down. * Mostly for code coverage. * * @throws SQLException * @throws InterruptedException */ @Test public void testInterruptedException() throws SQLException, InterruptedException { ArrayBlockingQueue<ConnectionHandle> fakeFreeConnections = new ArrayBlockingQueue<ConnectionHandle>(1); fakeFreeConnections.add(mockConnection); config.setIdleConnectionTestPeriod(1); expect(mockPool.getConfig()).andReturn(config).anyTimes(); expect(mockConnectionPartition.getFreeConnections()).andReturn(fakeFreeConnections).anyTimes(); expect(mockConnectionPartition.getMinConnections()).andReturn(10).once(); expect(mockConnection.isPossiblyBroken()).andReturn(false); expect(mockConnection.getConnectionLastUsed()).andReturn(0L); expect(mockPool.isConnectionHandleAlive((ConnectionHandle) anyObject())) .andReturn(true) .anyTimes(); expect(mockExecutor.isShutdown()).andReturn(true); mockPool.releaseInAnyFreePartition( (ConnectionHandle) anyObject(), (ConnectionPartition) anyObject()); expectLastCall().andThrow(new InterruptedException()); // connection should be closed mockConnection.internalClose(); mockPool.postDestroyConnection(mockConnection); expectLastCall().once(); replay(mockPool, mockConnection, mockConnectionPartition, mockExecutor); this.testClass = new ConnectionTesterThread(mockConnectionPartition, mockExecutor, mockPool); this.testClass.run(); verify(mockPool, mockConnectionPartition, mockExecutor, mockConnection); }
/** @throws SQLException */ @Test public void testCloseConnectionWithException() throws SQLException { ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class); mockPool.postDestroyConnection(mockConnection); expectLastCall().once(); mockConnection.internalClose(); expectLastCall().andThrow(new SQLException()); replay(mockConnection, mockPool); testClass.closeConnection(mockConnection); verify(mockConnection, mockPool); }
/** @throws SQLException */ @Test public void testCloseConnectionWithExceptionCoverage() throws SQLException { ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class); mockPool.postDestroyConnection(mockConnection); expectLastCall().once(); ConnectionMaxAgeThread.logger = null; // make it break. mockConnection.internalClose(); expectLastCall().andThrow(new SQLException()); replay(mockConnection, mockPool); try { testClass.closeConnection(mockConnection); } catch (Exception e) { // do nothing } verify(mockConnection, mockPool); }
/** * Tests that a connection that is marked broken is closed internally and that the partition is * marked as being able to create new connections. * * @throws SQLException */ @Test public void testConnectionMarkedBroken() throws SQLException { ArrayBlockingQueue<ConnectionHandle> fakeFreeConnections = new ArrayBlockingQueue<ConnectionHandle>(1); fakeFreeConnections.add(mockConnection); expect(mockPool.getConfig()).andReturn(config).anyTimes(); expect(mockConnectionPartition.getFreeConnections()).andReturn(fakeFreeConnections).anyTimes(); expect(mockConnection.isPossiblyBroken()).andReturn(true); // connection should be closed mockConnection.internalClose(); mockPool.postDestroyConnection(mockConnection); expectLastCall().once(); replay(mockPool, mockConnection, mockConnectionPartition, mockExecutor); this.testClass = new ConnectionTesterThread(mockConnectionPartition, mockExecutor, mockPool); this.testClass.run(); verify(mockPool, mockConnectionPartition, mockExecutor, mockConnection); }