/** Test for clear statement caches. */
@Test
public void testClearStatementCaches() {
testClass.statementCachingEnabled = true;
mockPreparedStatementCache.clear();
expectLastCall().once();
mockCallableStatementCache.clear();
expectLastCall().once();
replay(mockPreparedStatementCache, mockCallableStatementCache);
testClass.clearStatementCaches(true);
verify(mockPreparedStatementCache, mockCallableStatementCache);
reset(mockPreparedStatementCache, mockCallableStatementCache);
mockPool.closeConnectionWatch = true;
mockPreparedStatementCache.checkForProperClosure();
expectLastCall().once();
mockCallableStatementCache.checkForProperClosure();
expectLastCall().once();
replay(mockPreparedStatementCache, mockCallableStatementCache);
testClass.clearStatementCaches(false);
verify(mockPreparedStatementCache, mockCallableStatementCache);
}
/**
* Test routine for callable statements.
*
* @param args
* @throws SecurityException
* @throws NoSuchFieldException
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
@SuppressWarnings("unchecked")
private void callableStatementTest(Class... args)
throws SecurityException, NoSuchFieldException, IllegalArgumentException,
IllegalAccessException, NoSuchMethodException, InvocationTargetException {
Object[] params = new Object[args.length];
for (int i = 0; i < args.length; i++) {
params[i] = CommonTestUtils.instanceMap.get(args[i]);
}
Method prepCallMethod = testClass.getClass().getMethod("prepareCall", args);
CallableStatementHandle mockStatement = createNiceMock(CallableStatementHandle.class);
ConcurrentLinkedQueue<Statement> mockStatementHandles =
createNiceMock(ConcurrentLinkedQueue.class);
testClass.renewConnection(); // logically open the connection
// fetching a statement that is found in cache. Statement should be returned and marked as being
// (logically) open
doStatementMock(mockCallableStatementCache, mockStatement, params, args);
//
// expect(mockCallableStatementCache.get((String)anyObject())).andReturn(mockStatement).anyTimes();
((StatementHandle) mockStatement).setLogicallyOpen();
expectLastCall();
replay(mockStatement, mockCallableStatementCache);
prepCallMethod.invoke(testClass, params);
verify(mockStatement, mockCallableStatementCache);
reset(mockStatement, mockCallableStatementCache, mockStatementHandles);
// test for a cache miss
doStatementMock(mockCallableStatementCache, null, params, args);
// we should be creating the preparedStatement because it's not in the cache
expect(prepCallMethod.invoke(mockConnection, params)).andReturn(mockStatement);
// we should be tracking this statement
expect(mockStatementHandles.add(mockStatement)).andReturn(true);
replay(mockStatement, mockCallableStatementCache, mockConnection, mockStatementHandles);
prepCallMethod.invoke(testClass, params);
verify(mockStatement, mockCallableStatementCache, mockConnection);
// test for cache miss + sql exception
reset(mockStatement, mockCallableStatementCache, mockConnection);
Method mockConnectionPrepareCallMethod =
mockConnection.getClass().getMethod("prepareCall", args);
// expect(mockCallableStatementCache.get((String)anyObject())).andReturn(null).once();
doStatementMock(mockCallableStatementCache, null, params, args);
// we should be creating the preparedStatement because it's not in the cache
expect(mockConnectionPrepareCallMethod.invoke(mockConnection, params))
.andThrow(new SQLException("test", "Z"));
replay(mockStatement, mockCallableStatementCache, mockConnection);
try {
prepCallMethod.invoke(testClass, params);
fail("Should have thrown an exception");
} catch (Throwable t) {
// do nothing
}
verify(mockStatement, mockCallableStatementCache, mockConnection);
// test for no cache defined
reset(mockStatement, mockCallableStatementCache, mockConnection);
boolean oldState = testClass.statementCachingEnabled;
testClass.statementCachingEnabled = false;
// we should be creating the preparedStatement because it's not in the cache
expect(mockConnectionPrepareCallMethod.invoke(mockConnection, params)).andReturn(mockStatement);
replay(mockStatement, mockCallableStatementCache, mockConnection);
prepCallMethod.invoke(testClass, params);
verify(mockStatement, mockCallableStatementCache, mockConnection);
// restore sanity
testClass.statementCachingEnabled = oldState;
reset(mockStatement, mockCallableStatementCache, mockConnection);
}
