Category

Development Platform
Home > SourceCode/Document > Java Develop > View Code
JdbcTemplateTestSuite.java
Package: spring-framework-1.1.1-with-dependencies.zip　[view]
Upload User: jiancairen
Upload Date: 2007-08-27
Package Size: 26458k
Code Size: 59k
Category:

Java Develop

Development Platform:

Java

JdbcTemplateTestSuite.java：Code Content
  1. /*
  2.  * Copyright 2002-2004 the original author or authors.
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */ 
  17. package org.springframework.jdbc.core;
  19. import java.sql.CallableStatement;
  20. import java.sql.Connection;
  21. import java.sql.DatabaseMetaData;
  22. import java.sql.PreparedStatement;
  23. import java.sql.ResultSet;
  24. import java.sql.ResultSetMetaData;
  25. import java.sql.SQLException;
  26. import java.sql.SQLWarning;
  27. import java.sql.Statement;
  28. import java.util.ArrayList;
  29. import java.util.LinkedList;
  30. import java.util.List;
  31. import java.util.Map;
  33. import javax.sql.DataSource;
  35. import org.easymock.MockControl;
  37. import org.springframework.dao.DataAccessException;
  38. import org.springframework.dao.InvalidDataAccessApiUsageException;
  39. import org.springframework.dao.UncategorizedDataAccessException;
  40. import org.springframework.jdbc.AbstractJdbcTests;
  41. import org.springframework.jdbc.BadSqlGrammarException;
  42. import org.springframework.jdbc.CannotGetJdbcConnectionException;
  43. import org.springframework.jdbc.SQLWarningException;
  44. import org.springframework.jdbc.UncategorizedSQLException;
  45. import org.springframework.jdbc.datasource.SingleConnectionDataSource;
  46. import org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator;
  47. import org.springframework.jdbc.support.SQLStateSQLExceptionTranslator;
  48. import org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor;
  50. /** 
  51.  * Mock object based tests for JdbcTemplate.
  52.  * @author Rod Johnson
  53.  */
  54. public class JdbcTemplateTestSuite extends AbstractJdbcTests {
  56. public void testBeanProperties() throws Exception {
  57. replay();
  59. JdbcTemplate t = new JdbcTemplate(mockDataSource);
  60. assertTrue("datasource ok", t.getDataSource() == mockDataSource);
  61. assertTrue("ignores warnings by default", t.getIgnoreWarnings());
  62. t.setIgnoreWarnings(false);
  63. assertTrue("can set NOT to ignore warnings", !t.getIgnoreWarnings());
  64. }
  66. public void testCannotRunStaticSqlWithBindParameters() throws Exception {
  67. final String sql = "UPDATE FOO SET NAME='tony' WHERE ID > ?";
  69. replay();
  71. JdbcTemplate t = new JdbcTemplate(mockDataSource);
  72. try {
  73. t.query(sql, new RowCountCallbackHandler());
  74. fail("Should have objected to bind variables");
  75. }
  76. catch (InvalidDataAccessApiUsageException ex) {
  77. // Ok 
  78. }
  79. }
  81. public void testUpdateCount() throws Exception {
  82. final String sql =
  83. "UPDATE INVOICE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?";
  84. int idParam = 11111;
  86. MockControl ctrlPreparedStatement =
  87. MockControl.createControl(PreparedStatement.class);
  88. PreparedStatement mockPreparedStatement =
  89. (PreparedStatement) ctrlPreparedStatement.getMock();
  90. mockPreparedStatement.setInt(1, idParam);
  91. ctrlPreparedStatement.setVoidCallable();
  92. mockPreparedStatement.executeUpdate();
  93. ctrlPreparedStatement.setReturnValue(1);
  94. mockPreparedStatement.getWarnings();
  95. ctrlPreparedStatement.setReturnValue(null);
  96. mockPreparedStatement.close();
  97. ctrlPreparedStatement.setVoidCallable();
  99. mockConnection.prepareStatement(sql);
  100. ctrlConnection.setReturnValue(mockPreparedStatement);
  102. ctrlPreparedStatement.replay();
  103. replay();
  105. Dispatcher d = new Dispatcher(idParam, sql);
  106. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  108. int rowsAffected = template.update(d);
  109. assertTrue("1 update affected 1 row", rowsAffected == 1);
  111. /*
  112. d = new Dispatcher(idParam);
  113. rowsAffected = template.update(d);
  114. assertTrue("bogus update affected 0 rows", rowsAffected == 0);
  115. */
  117. ctrlPreparedStatement.verify();
  118. }
  120. public void testBogusUpdate() throws Exception {
  121. final String sql =
  122. "UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?";
  123. final int idParam = 6666;
  125. // It's because Integers aren't canonical
  126. SQLException sex = new SQLException("bad update");
  128. MockControl ctrlPreparedStatement =
  129. MockControl.createControl(PreparedStatement.class);
  130. PreparedStatement mockPreparedStatement =
  131. (PreparedStatement) ctrlPreparedStatement.getMock();
  132. mockPreparedStatement.setInt(1, idParam);
  133. ctrlPreparedStatement.setVoidCallable();
  134. mockPreparedStatement.executeUpdate();
  135. ctrlPreparedStatement.setThrowable(sex);
  136. mockPreparedStatement.close();
  137. ctrlPreparedStatement.setVoidCallable();
  139. mockConnection.prepareStatement(sql);
  140. ctrlConnection.setReturnValue(mockPreparedStatement);
  142. ctrlPreparedStatement.replay();
  143. replay();
  145. Dispatcher d = new Dispatcher(idParam, sql);
  146. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  148. try {
  149. template.update(d);
  150. fail("Bogus update should throw exception");
  151. }
  152. catch (UncategorizedDataAccessException ex) {
  153. // pass
  154. assertTrue(
  155. "Correct exception",
  156. ex instanceof UncategorizedSQLException);
  157. assertTrue("Root cause is correct", ex.getCause() == sex);
  158. //assertTrue("no update occurred", !je.getDataWasUpdated());
  159. }
  161. ctrlPreparedStatement.verify();
  162. }
  164. public void testStringsWithStaticSql() throws Exception {
  165. doTestStrings(new JdbcTemplateCallback() {
  166. public void doInJdbcTemplate(JdbcTemplate template, String sql, RowCallbackHandler rch) {
  167. template.query(sql, rch);
  168. }
  169. }, false, null);
  170. }
  172. public void testStringsWithEmptyPreparedStatementSetter() throws Exception {
  173. doTestStrings(new JdbcTemplateCallback() {
  174. public void doInJdbcTemplate(JdbcTemplate template, String sql, RowCallbackHandler rch) {
  175. template.query(sql, (PreparedStatementSetter) null, rch);
  176. }
  177. }, true, null);
  178. }
  180. public void testStringsWithPreparedStatementSetter() throws Exception {
  181. final Integer argument = new Integer(99);
  182. doTestStrings(new JdbcTemplateCallback() {
  183. public void doInJdbcTemplate(JdbcTemplate template, String sql, RowCallbackHandler rch) {
  184. template.query(sql, new PreparedStatementSetter() {
  185. public void setValues(PreparedStatement ps) throws SQLException {
  186. ps.setObject(1, argument);
  187. }
  188. }, rch);
  189. }
  190. }, true, argument);
  191. }
  193. public void testStringsWithEmptyPreparedStatementArgs() throws Exception {
  194. doTestStrings(new JdbcTemplateCallback() {
  195. public void doInJdbcTemplate(JdbcTemplate template, String sql, RowCallbackHandler rch) {
  196. template.query(sql, (Object[]) null, rch);
  197. }
  198. }, true, null);
  199. }
  201. public void testStringsWithPreparedStatementArgs() throws Exception {
  202. final Integer argument = new Integer(99);
  203. doTestStrings(new JdbcTemplateCallback() {
  204. public void doInJdbcTemplate(JdbcTemplate template, String sql, RowCallbackHandler rch) {
  205. template.query(sql, new Object[] {argument}, rch);
  206. }
  207. }, true, argument);
  208. }
  210. protected void doTestStrings(JdbcTemplateCallback jdbcTemplateCallback,
  211.                              boolean usePreparedStatement, Object argument) throws Exception {
  212. String sql = "SELECT FORENAME FROM CUSTMR";
  213. String[] results = { "rod", "gary", " portia" };
  215. class StringHandler implements RowCallbackHandler {
  216. private List l = new LinkedList();
  217. public void processRow(ResultSet rs) throws SQLException {
  218. l.add(rs.getString(1));
  219. }
  220. public String[] getStrings() {
  221. return (String[]) l.toArray(new String[l.size()]);
  222. }
  223. }
  225. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  226. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  227. mockResultSet.next();
  228. ctrlResultSet.setReturnValue(true);
  229. mockResultSet.getString(1);
  230. ctrlResultSet.setReturnValue(results[0]);
  231. mockResultSet.next();
  232. ctrlResultSet.setReturnValue(true);
  233. mockResultSet.getString(1);
  234. ctrlResultSet.setReturnValue(results[1]);
  235. mockResultSet.next();
  236. ctrlResultSet.setReturnValue(true);
  237. mockResultSet.getString(1);
  238. ctrlResultSet.setReturnValue(results[2]);
  239. mockResultSet.next();
  240. ctrlResultSet.setReturnValue(false);
  241. mockResultSet.close();
  242. ctrlResultSet.setVoidCallable();
  244. MockControl ctrlStatement =
  245. MockControl.createControl(PreparedStatement.class);
  246. PreparedStatement mockStatement =
  247. (PreparedStatement) ctrlStatement.getMock();
  248. if (argument != null) {
  249. mockStatement.setObject(1, argument);
  250. }
  251. if (usePreparedStatement) {
  252. mockStatement.executeQuery();
  253. }
  254. else {
  255. mockStatement.executeQuery(sql);
  256. }
  257. ctrlStatement.setReturnValue(mockResultSet);
  258. mockStatement.getWarnings();
  259. ctrlStatement.setReturnValue(null);
  260. mockStatement.close();
  261. ctrlStatement.setVoidCallable();
  263. if (usePreparedStatement) {
  264. mockConnection.prepareStatement(sql);
  265. }
  266. else {
  267. mockConnection.createStatement();
  268. }
  269. ctrlConnection.setReturnValue(mockStatement);
  271. ctrlResultSet.replay();
  272. ctrlStatement.replay();
  273. replay();
  275. StringHandler sh = new StringHandler();
  276. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  277. jdbcTemplateCallback.doInJdbcTemplate(template, sql, sh);
  279. // Match
  280. String[] forenames = sh.getStrings();
  281. assertTrue("same length", forenames.length == results.length);
  282. for (int i = 0; i < forenames.length; i++) {
  283. assertTrue("Row " + i + " matches", forenames[i].equals(results[i]));
  284. }
  286. ctrlResultSet.verify();
  287. ctrlStatement.verify();
  288. }
  290. public void testLeaveConnOpenOnRequest() throws Exception {
  291. String sql = "SELECT ID, FORENAME FROM CUSTMR WHERE ID < 3";
  293. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  294. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  295. ctrlResultSet = MockControl.createControl(ResultSet.class);
  296. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  297. mockResultSet.next();
  298. ctrlResultSet.setReturnValue(false);
  299. mockResultSet.close();
  300. ctrlResultSet.setVoidCallable();
  302. MockControl ctrlStatement = MockControl.createControl(PreparedStatement.class);
  303. PreparedStatement mockStatement = (PreparedStatement) ctrlStatement.getMock();
  304. ctrlStatement = MockControl.createControl(PreparedStatement.class);
  305. mockStatement = (PreparedStatement) ctrlStatement.getMock();
  306. mockStatement.executeQuery(sql);
  307. ctrlStatement.setReturnValue(mockResultSet);
  308. mockStatement.getWarnings();
  309. ctrlStatement.setReturnValue(null);
  310. mockStatement.close();
  311. ctrlStatement.setVoidCallable();
  313. mockConnection.isClosed();
  314. ctrlConnection.setReturnValue(false, 2);
  315. mockConnection.createStatement();
  316. ctrlConnection.setReturnValue(mockStatement);
  317. // if close is called entire test will fail
  318. mockConnection.close();
  319. ctrlConnection.setDefaultThrowable(new RuntimeException());
  321. ctrlResultSet.replay();
  322. ctrlStatement.replay();
  323. replay();
  325. SingleConnectionDataSource scf = new SingleConnectionDataSource(mockDataSource.getConnection(), false);
  326. JdbcTemplate template2 = new JdbcTemplate(scf);
  327. RowCountCallbackHandler rcch = new RowCountCallbackHandler();
  328. template2.query(sql, rcch);
  330. ctrlResultSet.verify();
  331. ctrlStatement.verify();
  332. }
  334. public void testCloseConnOnRequest() throws Exception {
  335. String sql = "SELECT ID, FORENAME FROM CUSTMR WHERE ID < 3";
  337. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  338. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  339. mockResultSet.next();
  340. ctrlResultSet.setReturnValue(false);
  341. mockResultSet.close();
  342. ctrlResultSet.setVoidCallable();
  344. MockControl ctrlStatement = MockControl.createControl(PreparedStatement.class);
  345. PreparedStatement mockStatement = (PreparedStatement) ctrlStatement.getMock();
  346. mockStatement.executeQuery(sql);
  347. ctrlStatement.setReturnValue(mockResultSet);
  348. mockStatement.getWarnings();
  349. ctrlStatement.setReturnValue(null);
  350. mockStatement.close();
  351. ctrlStatement.setVoidCallable();
  353. mockConnection.createStatement();
  354. ctrlConnection.setReturnValue(mockStatement);
  356. ctrlResultSet.replay();
  357. ctrlStatement.replay();
  358. replay();
  360. JdbcTemplate template2 = new JdbcTemplate(mockDataSource);
  361. RowCountCallbackHandler rcch = new RowCountCallbackHandler();
  362. template2.query(sql, rcch);
  364. ctrlResultSet.verify();
  365. ctrlStatement.verify();
  366. }
  368. /**
  369.  * Test that we see a runtime exception come back.
  370.  */
  371. public void testExceptionComesBack() throws Exception {
  372. final String sql = "SELECT ID FROM CUSTMR";
  373. final RuntimeException rex = new RuntimeException("What I want to see");
  375. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  376. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  377. mockResultSet.next();
  378. ctrlResultSet.setReturnValue(true);
  379. mockResultSet.close();
  380. ctrlResultSet.setVoidCallable();
  382. MockControl ctrlStatement = MockControl.createControl(PreparedStatement.class);
  383. PreparedStatement mockStatement = (PreparedStatement) ctrlStatement.getMock();
  384. mockStatement.executeQuery(sql);
  385. ctrlStatement.setReturnValue(mockResultSet);
  386. mockStatement.getWarnings();
  387. ctrlStatement.setReturnValue(null);
  388. mockStatement.close();
  389. ctrlStatement.setVoidCallable();
  391. mockConnection.createStatement();
  392. ctrlConnection.setReturnValue(mockStatement);
  394. ctrlResultSet.replay();
  395. ctrlStatement.replay();
  396. replay();
  398. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  399. try {
  400. template.query(sql, new RowCallbackHandler() {
  401. public void processRow(java.sql.ResultSet rs)
  402. throws java.sql.SQLException {
  403. throw rex;
  404. }
  405. });
  406. fail("Should have thrown exception");
  407. }
  408. catch (RuntimeException ex) {
  409. assertTrue("Wanted same exception back, not " + ex, ex == rex);
  410. }
  411. }
  413. /**
  414.  * Test update with static SQL.
  415.  */
  416. public void testSqlUpdate() throws Exception {
  417. final String sql = "UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = 4";
  418. int rowsAffected = 33;
  420. MockControl ctrlStatement = MockControl.createControl(Statement.class);
  421. Statement mockStatement = (Statement) ctrlStatement.getMock();
  422. mockStatement.executeUpdate(sql);
  423. ctrlStatement.setReturnValue(rowsAffected);
  424. mockStatement.getWarnings();
  425. ctrlStatement.setReturnValue(null);
  426. mockStatement.close();
  427. ctrlStatement.setVoidCallable();
  429. mockConnection.createStatement();
  430. ctrlConnection.setReturnValue(mockStatement);
  432. ctrlStatement.replay();
  433. replay();
  435. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  437. int actualRowsAffected = template.update(sql);
  438. assertTrue(
  439. "Actual rows affected is correct",
  440. actualRowsAffected == rowsAffected);
  442. ctrlStatement.verify();
  443. }
  445. public void testSqlUpdateEncountersSqlException() throws Exception {
  446. SQLException sex = new SQLException("bad update");
  447. final String sql = "UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = 4";
  449. MockControl ctrlStatement = MockControl.createControl(Statement.class);
  450. Statement mockStatement = (Statement) ctrlStatement.getMock();
  451. mockStatement.executeUpdate(sql);
  452. ctrlStatement.setThrowable(sex);
  453. mockStatement.close();
  454. ctrlStatement.setVoidCallable();
  456. mockConnection.createStatement();
  457. ctrlConnection.setReturnValue(mockStatement);
  459. ctrlStatement.replay();
  460. replay();
  462. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  463. try {
  464. template.update(sql);
  465. }
  466. catch (DataAccessException ex) {
  467. assertTrue("root cause is correct", ex.getCause() == sex);
  468. }
  470. ctrlStatement.verify();
  471. }
  473. public void testSqlUpdateWithThreadConnection() throws Exception {
  474. final String sql = "UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = 4";
  475. int rowsAffected = 33;
  477. MockControl ctrlStatement = MockControl.createControl(Statement.class);
  478. Statement mockStatement = (Statement) ctrlStatement.getMock();
  479. mockStatement.executeUpdate(sql);
  480. ctrlStatement.setReturnValue(rowsAffected);
  481. mockStatement.getWarnings();
  482. ctrlStatement.setReturnValue(null);
  483. mockStatement.close();
  484. ctrlStatement.setVoidCallable();
  486. mockConnection.createStatement();
  487. ctrlConnection.setReturnValue(mockStatement);
  489. ctrlStatement.replay();
  490. replay();
  492. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  494. int actualRowsAffected = template.update(sql);
  495. assertTrue(
  496. "Actual rows affected is correct",
  497. actualRowsAffected == rowsAffected);
  499. ctrlStatement.verify();
  500. }
  502. public void testBatchUpdate() throws Exception {
  503. final String sql = "UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?";
  504. final int[] ids = new int[] { 100, 200 };
  506. MockControl ctrlPreparedStatement = MockControl.createControl(PreparedStatement.class);
  507. PreparedStatement mockPreparedStatement = (PreparedStatement) ctrlPreparedStatement.getMock();
  508. mockPreparedStatement.getConnection();
  509. ctrlPreparedStatement.setReturnValue(mockConnection);
  510. mockPreparedStatement.setInt(1, ids[0]);
  511. ctrlPreparedStatement.setVoidCallable();
  512. mockPreparedStatement.addBatch();
  513. ctrlPreparedStatement.setVoidCallable();
  514. mockPreparedStatement.setInt(1, ids[1]);
  515. ctrlPreparedStatement.setVoidCallable();
  516. mockPreparedStatement.addBatch();
  517. ctrlPreparedStatement.setVoidCallable();
  518. mockPreparedStatement.executeBatch();
  519. ctrlPreparedStatement.setReturnValue(ids);
  520. mockPreparedStatement.getWarnings();
  521. ctrlPreparedStatement.setReturnValue(null);
  522. mockPreparedStatement.close();
  523. ctrlPreparedStatement.setVoidCallable();
  525. MockControl ctrlDatabaseMetaData = MockControl.createControl(DatabaseMetaData.class);
  526. DatabaseMetaData mockDatabaseMetaData = (DatabaseMetaData) ctrlDatabaseMetaData.getMock();
  527. mockDatabaseMetaData.getDatabaseProductName();
  528. ctrlDatabaseMetaData.setReturnValue("MySQL");
  529. mockDatabaseMetaData.getDriverVersion();
  530. ctrlDatabaseMetaData.setReturnValue("1.2.3");
  531. mockDatabaseMetaData.supportsBatchUpdates();
  532. ctrlDatabaseMetaData.setReturnValue(true);
  534. mockConnection.prepareStatement(sql);
  535. ctrlConnection.setReturnValue(mockPreparedStatement);
  536. mockConnection.getMetaData();
  537. ctrlConnection.setReturnValue(mockDatabaseMetaData, 2);
  539. ctrlPreparedStatement.replay();
  540. ctrlDatabaseMetaData.replay();
  541. replay();
  543. BatchPreparedStatementSetter setter =
  544. new BatchPreparedStatementSetter() {
  545. public void setValues(PreparedStatement ps, int i)
  546. throws SQLException {
  547. ps.setInt(1, ids[i]);
  548. }
  549. public int getBatchSize() {
  550. return ids.length;
  551. }
  552. };
  554. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  556. int[] actualRowsAffected = template.batchUpdate(sql, setter);
  557. assertTrue("executed 2 updates", actualRowsAffected.length == 2);
  559. ctrlPreparedStatement.verify();
  560. ctrlDatabaseMetaData.verify();
  561. }
  563. public void testBatchUpdateWithNoBatchSupport() throws Exception {
  564. final String sql = "UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?";
  565. final int[] ids = new int[] { 100, 200 };
  567. MockControl ctrlPreparedStatement = MockControl.createControl(PreparedStatement.class);
  568. PreparedStatement mockPreparedStatement = (PreparedStatement) ctrlPreparedStatement.getMock();
  569. mockPreparedStatement.getConnection();
  570. ctrlPreparedStatement.setReturnValue(mockConnection);
  571. mockPreparedStatement.setInt(1, ids[0]);
  572. ctrlPreparedStatement.setVoidCallable();
  573. mockPreparedStatement.executeUpdate();
  574. ctrlPreparedStatement.setReturnValue(ids[0]);
  575. mockPreparedStatement.setInt(1, ids[1]);
  576. ctrlPreparedStatement.setVoidCallable();
  577. mockPreparedStatement.executeUpdate();
  578. ctrlPreparedStatement.setReturnValue(ids[1]);
  579. mockPreparedStatement.getWarnings();
  580. ctrlPreparedStatement.setReturnValue(null);
  581. mockPreparedStatement.close();
  582. ctrlPreparedStatement.setVoidCallable();
  584. mockConnection.prepareStatement(sql);
  585. ctrlConnection.setReturnValue(mockPreparedStatement);
  587. ctrlPreparedStatement.replay();
  588. replay();
  590. BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter() {
  591. public void setValues(PreparedStatement ps, int i) throws SQLException {
  592. ps.setInt(1, ids[i]);
  593. }
  594. public int getBatchSize() {
  595. return ids.length;
  596. }
  597. };
  599. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  601. int[] actualRowsAffected = template.batchUpdate(sql, setter);
  602. assertTrue("executed 2 updates", actualRowsAffected.length == 2);
  604. ctrlPreparedStatement.verify();
  605. }
  607. public void testBatchUpdateFails() throws Exception {
  608. final String sql = "UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?";
  609. final int[] ids = new int[] { 100, 200 };
  610. SQLException sex = new SQLException();
  612. MockControl ctrlPreparedStatement = MockControl.createControl(PreparedStatement.class);
  613. PreparedStatement mockPreparedStatement = (PreparedStatement) ctrlPreparedStatement.getMock();
  614. mockPreparedStatement.getConnection();
  615. ctrlPreparedStatement.setReturnValue(mockConnection);
  616. mockPreparedStatement.setInt(1, ids[0]);
  617. ctrlPreparedStatement.setVoidCallable();
  618. mockPreparedStatement.addBatch();
  619. ctrlPreparedStatement.setVoidCallable();
  620. mockPreparedStatement.setInt(1, ids[1]);
  621. ctrlPreparedStatement.setVoidCallable();
  622. mockPreparedStatement.addBatch();
  623. ctrlPreparedStatement.setVoidCallable();
  624. mockPreparedStatement.executeBatch();
  625. ctrlPreparedStatement.setThrowable(sex);
  626. mockPreparedStatement.close();
  627. ctrlPreparedStatement.setVoidCallable();
  629. MockControl ctrlDatabaseMetaData = MockControl.createControl(DatabaseMetaData.class);
  630. DatabaseMetaData mockDatabaseMetaData = (DatabaseMetaData) ctrlDatabaseMetaData.getMock();
  631. mockDatabaseMetaData.getDatabaseProductName();
  632. ctrlDatabaseMetaData.setReturnValue("MySQL");
  633. mockDatabaseMetaData.getDriverVersion();
  634. ctrlDatabaseMetaData.setReturnValue("1.2.3");
  635. mockDatabaseMetaData.supportsBatchUpdates();
  636. ctrlDatabaseMetaData.setReturnValue(true);
  638. ctrlConnection.reset();
  639. mockConnection.prepareStatement(sql);
  640. ctrlConnection.setReturnValue(mockPreparedStatement);
  641. mockConnection.getMetaData();
  642. ctrlConnection.setReturnValue(mockDatabaseMetaData, 2);
  643. mockConnection.close();
  644. ctrlConnection.setVoidCallable(2);
  646. ctrlPreparedStatement.replay();
  647. ctrlDatabaseMetaData.replay();
  648. replay();
  650. BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter() {
  651. public void setValues(PreparedStatement ps, int i) throws SQLException {
  652. ps.setInt(1, ids[i]);
  653. }
  654. public int getBatchSize() {
  655. return ids.length;
  656. }
  657. };
  659. try {
  660. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  661. template.batchUpdate(sql, setter);
  662. fail("Should have failed because of SQLException in bulk update");
  663. }
  664. catch (DataAccessException ex) {
  665. assertTrue("Root cause is SQLException", ex.getCause() == sex);
  666. }
  668. ctrlPreparedStatement.verify();
  669. ctrlDatabaseMetaData.verify();
  670. }
  672. public void testCouldntGetConnectionInOperationOrLazilyInstantiatedExceptionTranslator() throws SQLException {
  673. SQLException sex = new SQLException("foo", "07xxx");
  675. // Change behaviour in setUp() because we only expect one call to getConnection():
  676. // none is necessary to get metadata for exception translator
  677. ctrlDataSource = MockControl.createControl(DataSource.class);
  678. mockDataSource = (DataSource) ctrlDataSource.getMock();
  679. mockDataSource.getConnection();
  680. // Expect two calls (one call after caching data product name): make get Metadata fail also
  681. ctrlDataSource.setThrowable(sex, 2);
  682. replay();
  684. try {
  685. JdbcTemplate template2 = new JdbcTemplate(mockDataSource);
  686. RowCountCallbackHandler rcch = new RowCountCallbackHandler();
  687. template2.query("SELECT ID, FORENAME FROM CUSTMR WHERE ID < 3", rcch);
  688. fail("Shouldn't have executed query without a connection");
  689. } 
  690. catch (CannotGetJdbcConnectionException ex) {
  691. // pass
  692. assertTrue("Check root cause", ex.getCause() == sex);
  693. }
  695. ctrlDataSource.verify();
  696. }
  698. /**
  699.  * Verify that afterPropertiesSet invokes exception translator.
  700.  */
  701. public void testCouldntGetConnectionInOperationWithExceptionTranslatorInitialized() throws SQLException {
  702. SQLException sex = new SQLException("foo", "07xxx");
  704. ctrlDataSource = MockControl.createControl(DataSource.class);
  705. mockDataSource = (DataSource) ctrlDataSource.getMock();
  706. //mockConnection.getMetaData();
  707. //ctrlConnection.setReturnValue(null, 1);
  708. //mockConnection.close();
  709. //ctrlConnection.setVoidCallable(1);
  710. ctrlConnection.replay();
  712. // Change behaviour in setUp() because we only expect one call to getConnection():
  713. // none is necessary to get metadata for exception translator
  714. ctrlDataSource = MockControl.createControl(DataSource.class);
  715. mockDataSource = (DataSource) ctrlDataSource.getMock();
  716. // Upfront call for metadata - no longer the case
  717. //mockDataSource.getConnection();
  718. //ctrlDataSource.setReturnValue(mockConnection, 1);
  719. // One call for operation
  720. mockDataSource.getConnection();
  721. ctrlDataSource.setThrowable(sex, 2);
  722. ctrlDataSource.replay();
  724. try {
  725. JdbcTemplate template2 = new JdbcTemplate(mockDataSource);
  726. template2.afterPropertiesSet();
  727. RowCountCallbackHandler rcch = new RowCountCallbackHandler();
  728. template2.query("SELECT ID, FORENAME FROM CUSTMR WHERE ID < 3", rcch);
  729. fail("Shouldn't have executed query without a connection");
  730. } 
  731. catch (CannotGetJdbcConnectionException ex) {
  732. // pass
  733. assertTrue("Check root cause", ex.getCause() == sex);
  734. }
  736. ctrlDataSource.verify();
  737. ctrlConnection.verify();
  738. }
  740. public void testCouldntGetConnectionInOperationWithExceptionTranslatorInitializedViaBeanProperty()
  741. throws Exception {
  742. doTestCouldntGetConnectionInOperationWithExceptionTranslatorInitialized(true);
  743. }
  745. public void testCouldntGetConnectionInOperationWithExceptionTranslatorInitializedInAfterPropertiesSet()
  746. throws Exception {
  747. doTestCouldntGetConnectionInOperationWithExceptionTranslatorInitialized(false);
  748. }
  750. /**
  751.  * If beanProperty is true, initialize via exception translator bean property;
  752.  * if false, use afterPropertiesSet().
  753.  */
  754. private void doTestCouldntGetConnectionInOperationWithExceptionTranslatorInitialized(boolean beanProperty)
  755. throws SQLException {
  756. SQLException sex = new SQLException("foo", "07xxx");
  758. ctrlConnection = MockControl.createControl(Connection.class);
  759. mockConnection = (Connection) ctrlConnection.getMock();
  760. //mockConnection.getMetaData();
  761. //ctrlConnection.setReturnValue(null, 1);
  762. //mockConnection.close();
  763. //ctrlConnection.setVoidCallable(1);
  764. ctrlConnection.replay();
  766. // Change behaviour in setUp() because we only expect one call to getConnection():
  767. // none is necessary to get metadata for exception translator
  768. ctrlDataSource = MockControl.createControl(DataSource.class);
  769. mockDataSource = (DataSource) ctrlDataSource.getMock();
  770. // Upfront call for metadata - no longer the case
  771. //mockDataSource.getConnection();
  772. //ctrlDataSource.setReturnValue(mockConnection, 1);
  773. // One call for operation
  774. mockDataSource.getConnection();
  775. ctrlDataSource.setThrowable(sex, 2);
  776. ctrlDataSource.replay();
  778. try {
  779. JdbcTemplate template2 = new JdbcTemplate();
  780. template2.setDataSource(mockDataSource);
  781. if (beanProperty) {
  782. // This will get a connection.
  783. template2.setExceptionTranslator(new SQLErrorCodeSQLExceptionTranslator(mockDataSource));
  784. }
  785. else {
  786. // This will cause creation of default SQL translator.
  787. // Note that only call should be effective.
  788. template2.afterPropertiesSet();
  789. template2.afterPropertiesSet();
  790. }
  791. RowCountCallbackHandler rcch = new RowCountCallbackHandler();
  792. template2.query(
  793. "SELECT ID, FORENAME FROM CUSTMR WHERE ID < 3",
  794. rcch);
  795. fail("Shouldn't have executed query without a connection");
  796. } 
  797. catch (CannotGetJdbcConnectionException ex) {
  798. // pass
  799. assertTrue("Check root cause", ex.getCause() == sex);
  800. }
  802. ctrlDataSource.verify();
  803. ctrlConnection.verify();
  804. }
  806. public void testPreparedStatementSetterSucceeds() throws Exception {
  807. final String sql = "UPDATE FOO SET NAME=? WHERE ID = 1";
  808. final String name = "Gary";
  809. int expectedRowsUpdated = 1;
  811. MockControl ctrlPreparedStatement =
  812. MockControl.createControl(PreparedStatement.class);
  813. PreparedStatement mockPreparedStatement =
  814. (PreparedStatement) ctrlPreparedStatement.getMock();
  815. mockPreparedStatement.setString(1, name);
  816. ctrlPreparedStatement.setVoidCallable();
  817. mockPreparedStatement.executeUpdate();
  818. ctrlPreparedStatement.setReturnValue(expectedRowsUpdated);
  819. mockPreparedStatement.getWarnings();
  820. ctrlPreparedStatement.setReturnValue(null);
  821. mockPreparedStatement.close();
  822. ctrlPreparedStatement.setVoidCallable();
  824. mockConnection.prepareStatement(sql);
  825. ctrlConnection.setReturnValue(mockPreparedStatement);
  827. ctrlPreparedStatement.replay();
  828. replay();
  830. PreparedStatementSetter pss = new PreparedStatementSetter() {
  831. public void setValues(PreparedStatement ps) throws SQLException {
  832. ps.setString(1, name);
  833. }
  834. };
  835. int actualRowsUpdated =
  836. new JdbcTemplate(mockDataSource).update(sql, pss);
  837. assertTrue(
  838. "updated correct # of rows",
  839. actualRowsUpdated == expectedRowsUpdated);
  841. ctrlPreparedStatement.verify();
  842. }
  844. public void testPreparedStatementSetterFails() throws Exception {
  845. final String sql = "UPDATE FOO SET NAME=? WHERE ID = 1";
  846. final String name = "Gary";
  847. SQLException sex = new SQLException();
  849. MockControl ctrlPreparedStatement =
  850. MockControl.createControl(PreparedStatement.class);
  851. PreparedStatement mockPreparedStatement =
  852. (PreparedStatement) ctrlPreparedStatement.getMock();
  853. mockPreparedStatement.setString(1, name);
  854. ctrlPreparedStatement.setVoidCallable();
  855. mockPreparedStatement.executeUpdate();
  856. ctrlPreparedStatement.setThrowable(sex);
  857. mockPreparedStatement.close();
  858. ctrlPreparedStatement.setVoidCallable();
  860. mockConnection.prepareStatement(sql);
  861. ctrlConnection.setReturnValue(mockPreparedStatement);
  863. ctrlPreparedStatement.replay();
  864. replay();
  866. PreparedStatementSetter pss = new PreparedStatementSetter() {
  867. public void setValues(PreparedStatement ps) throws SQLException {
  868. ps.setString(1, name);
  869. }
  870. };
  871. try {
  872. new JdbcTemplate(mockDataSource).update(sql, pss);
  873. fail("Should have failed with SQLException");
  874. }
  875. catch (DataAccessException ex) {
  876. assertTrue("root cause was preserved", ex.getCause() == sex);
  877. }
  879. ctrlPreparedStatement.verify();
  880. }
  882. public void testCouldntClose() throws Exception {
  883. MockControl ctrlStatement = MockControl.createControl(Statement.class);
  884. Statement mockStatement = (Statement) ctrlStatement.getMock();
  885. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  886. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  887. mockConnection.createStatement();
  888. ctrlConnection.setReturnValue(mockStatement);
  889. String sql = "SELECT ID, FORENAME FROM CUSTMR WHERE ID < 3";
  890. mockStatement.executeQuery(sql);
  891. ctrlStatement.setReturnValue(mockResultSet);
  892. mockResultSet.next();
  893. ctrlResultSet.setReturnValue(false);
  894. SQLException sex = new SQLException("bar");
  895. mockResultSet.close();
  896. ctrlResultSet.setThrowable(sex);
  897. mockStatement.getWarnings();
  898. ctrlStatement.setReturnValue(null);
  899. mockStatement.close();
  900. ctrlStatement.setThrowable(sex);
  901. mockConnection.close();
  902. ctrlConnection.setThrowable(sex);
  904. ctrlStatement.replay();
  905. ctrlResultSet.replay();
  906. replay();
  908. JdbcTemplate template2 = new JdbcTemplate(mockDataSource);
  909. RowCountCallbackHandler rcch = new RowCountCallbackHandler();
  910. template2.query("SELECT ID, FORENAME FROM CUSTMR WHERE ID < 3", rcch);
  912. ctrlStatement.verify();
  913. ctrlResultSet.verify();
  914. }
  916. /**
  917.  * Mock objects allow us to produce warnings at will
  918.  */
  919. public void testFatalWarning() throws Exception {
  920. String sql = "SELECT forename from custmr";
  921. SQLWarning warnings = new SQLWarning("My warning");
  923. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  924. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  925. mockResultSet.next();
  926. ctrlResultSet.setReturnValue(false);
  927. mockResultSet.close();
  928. ctrlResultSet.setVoidCallable();
  930. MockControl ctrlStatement = MockControl.createControl(PreparedStatement.class);
  931. PreparedStatement mockStatement = (PreparedStatement) ctrlStatement.getMock();
  932. mockStatement.executeQuery(sql);
  933. ctrlStatement.setReturnValue(mockResultSet);
  934. mockStatement.getWarnings();
  935. ctrlStatement.setReturnValue(warnings);
  936. mockStatement.close();
  937. ctrlStatement.setVoidCallable();
  939. mockConnection.createStatement();
  940. ctrlConnection.setReturnValue(mockStatement);
  942. ctrlResultSet.replay();
  943. ctrlStatement.replay();
  944. replay();
  946. JdbcTemplate t = new JdbcTemplate(mockDataSource);
  947. t.setIgnoreWarnings(false);
  948. try {
  949. t.query(sql, new RowCallbackHandler() {
  950. public void processRow(java.sql.ResultSet rs)
  951. throws java.sql.SQLException {
  952. rs.getByte(1);
  953. }
  954. });
  955. fail("Should have thrown exception on warning");
  956. }
  957. catch (SQLWarningException ex) {
  958. // Pass
  959. assertTrue(
  960. "Root cause of warning was correct",
  961. ex.getCause() == warnings);
  962. }
  964. ctrlResultSet.verify();
  965. ctrlStatement.verify();
  966. }
  968. public void testIgnoredWarning() throws Exception {
  969. String sql = "SELECT forename from custmr";
  970. SQLWarning warnings = new SQLWarning("My warning");
  972. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  973. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  974. mockResultSet.next();
  975. ctrlResultSet.setReturnValue(false);
  976. mockResultSet.close();
  977. ctrlResultSet.setVoidCallable();
  979. MockControl ctrlStatement =
  980. MockControl.createControl(PreparedStatement.class);
  981. PreparedStatement mockStatement =
  982. (PreparedStatement) ctrlStatement.getMock();
  983. mockStatement.executeQuery(sql);
  984. ctrlStatement.setReturnValue(mockResultSet);
  985. mockStatement.getWarnings();
  986. ctrlStatement.setReturnValue(warnings);
  987. mockStatement.close();
  988. ctrlStatement.setVoidCallable();
  990. mockConnection.createStatement();
  991. ctrlConnection.setReturnValue(mockStatement);
  993. ctrlResultSet.replay();
  994. ctrlStatement.replay();
  995. replay();
  997. // Too long: truncation
  998. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  999. template.setIgnoreWarnings(true);
  1000. template.query(sql, new RowCallbackHandler() {
  1001. public void processRow(java.sql.ResultSet rs)
  1002. throws java.sql.SQLException {
  1003. rs.getByte(1);
  1004. }
  1005. });
  1007. ctrlResultSet.verify();
  1008. ctrlStatement.verify();
  1009. }
  1011. /**
  1012.  * Test that we see an SQLException translated using Error Code
  1013.  */
  1014. public void testSQLErrorCodeTranslation() throws Exception {
  1015. final SQLException sex = new SQLException("I have a known problem", "99999", 1054);
  1016. final String sql = "SELECT ID FROM CUSTOMER";
  1018. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  1019. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1020. mockResultSet.next();
  1021. ctrlResultSet.setReturnValue(true);
  1022. mockResultSet.close();
  1023. ctrlResultSet.setVoidCallable();
  1025. MockControl ctrlStatement = MockControl.createControl(PreparedStatement.class);
  1026. PreparedStatement mockStatement = (PreparedStatement) ctrlStatement.getMock();
  1027. mockStatement.executeQuery(sql);
  1028. ctrlStatement.setReturnValue(mockResultSet);
  1029. mockStatement.close();
  1030. ctrlStatement.setVoidCallable();
  1032. MockControl ctrlDatabaseMetaData = MockControl.createControl(DatabaseMetaData.class);
  1033. DatabaseMetaData mockDatabaseMetaData = (DatabaseMetaData) ctrlDatabaseMetaData.getMock();
  1034. mockDatabaseMetaData.getDatabaseProductName();
  1035. ctrlDatabaseMetaData.setReturnValue("MySQL");
  1036. mockDatabaseMetaData.getDriverVersion();
  1037. ctrlDatabaseMetaData.setReturnValue("1.2.3");
  1039. mockConnection.createStatement();
  1040. ctrlConnection.setReturnValue(mockStatement);
  1041. mockConnection.getMetaData();
  1042. ctrlConnection.setReturnValue(mockDatabaseMetaData);
  1044. ctrlResultSet.replay();
  1045. ctrlStatement.replay();
  1046. ctrlDatabaseMetaData.replay();
  1047. replay();
  1049. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1050. try {
  1051. template.query(sql, new RowCallbackHandler() {
  1052. public void processRow(java.sql.ResultSet rs) throws SQLException {
  1053. throw sex;
  1054. }
  1055. });
  1056. fail("Should have thrown exception");
  1057. }
  1058. catch (BadSqlGrammarException ex) {
  1059. assertTrue("Wanted same exception back, not " + ex, sex == ex.getCause());
  1060. }
  1061. catch (Exception ex) {
  1062. fail("Should have thrown BadSqlGrammarException exception, not " + ex);
  1063. }
  1065. ctrlResultSet.verify();
  1066. ctrlStatement.verify();
  1067. }
  1069. /**
  1070.  * Test that we see an SQLException translated using Error Code.
  1071.  * If we provide the SQLExceptionTranslator, we shouldn't use a connection
  1072.  * to get the metadata
  1073.  */
  1074. public void testUseCustomSQLErrorCodeTranslator() throws Exception {
  1075. // Bad SQL state
  1076. final SQLException sex = new SQLException("I have a known problem", "07000", 1054);
  1077. final String sql = "SELECT ID FROM CUSTOMER";
  1079. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  1080. ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1081. mockResultSet.next();
  1082. ctrlResultSet.setReturnValue(true);
  1083. mockResultSet.close();
  1084. ctrlResultSet.setVoidCallable();
  1086. MockControl ctrlStatement = MockControl.createControl(PreparedStatement.class);
  1087. PreparedStatement mockStatement = (PreparedStatement) ctrlStatement.getMock();
  1088. mockStatement.executeQuery(sql);
  1089. ctrlStatement.setReturnValue(mockResultSet);
  1090. mockStatement.close();
  1091. ctrlStatement.setVoidCallable();
  1093. mockConnection.createStatement();
  1094. ctrlConnection.setReturnValue(mockStatement);
  1096. // Change behaviour in setUp() because we only expect one call to getConnection():
  1097. // none is necessary to get metadata for exception translator
  1098. ctrlConnection = MockControl.createControl(Connection.class);
  1099. mockConnection = (Connection) ctrlConnection.getMock();
  1100. mockConnection.createStatement();
  1101. ctrlConnection.setReturnValue(mockStatement, 1);
  1102. mockConnection.close();
  1103. ctrlConnection.setVoidCallable(1);
  1104. ctrlConnection.replay();
  1106. ctrlDataSource = MockControl.createControl(DataSource.class);
  1107. mockDataSource = (DataSource) ctrlDataSource.getMock();
  1108. mockDataSource.getConnection();
  1109. ctrlDataSource.setReturnValue(mockConnection, 1);
  1110. ctrlDataSource.replay();
  1111. ///// end changed behaviour
  1113. ctrlResultSet.replay();
  1114. ctrlStatement.replay();
  1116. JdbcTemplate template = new JdbcTemplate();
  1117. template.setDataSource(mockDataSource);
  1118. // Set custom exception translator
  1119. template.setExceptionTranslator(new SQLStateSQLExceptionTranslator());
  1120. template.afterPropertiesSet();
  1121. try {
  1122. template.query(sql, new RowCallbackHandler() {
  1123. public void processRow(java.sql.ResultSet rs)
  1124. throws SQLException {
  1125. throw sex;
  1126. }
  1127. });
  1128. fail("Should have thrown exception");
  1129. }
  1130. catch (BadSqlGrammarException ex) {
  1131. assertTrue(
  1132. "Wanted same exception back, not " + ex,
  1133. sex == ex.getCause());
  1134. } 
  1136. ctrlResultSet.verify();
  1137. ctrlStatement.verify();
  1139. // We didn't call superclass replay() so we need to check these ourselves
  1140. ctrlDataSource.verify();
  1141. ctrlConnection.verify();
  1142. }
  1144. public void testNativeJdbcExtractorInvoked() throws Exception {
  1145. MockControl ctrlResultSet = MockControl.createControl(ResultSet.class);
  1146. final ResultSet mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1147. mockResultSet.close();
  1148. ctrlResultSet.setVoidCallable(2);
  1150. MockControl ctrlStatement = MockControl.createControl(Statement.class);
  1151. final Statement mockStatement = (Statement) ctrlStatement.getMock();
  1152. mockStatement.getWarnings();
  1153. ctrlStatement.setReturnValue(null);
  1154. mockStatement.close();
  1155. ctrlStatement.setVoidCallable();
  1156. MockControl ctrlStatement2 = MockControl.createControl(Statement.class);
  1157. final Statement mockStatement2 = (Statement) ctrlStatement2.getMock();
  1158. mockStatement2.executeQuery("my query");
  1159. ctrlStatement2.setReturnValue(mockResultSet, 1);
  1161. MockControl ctrlPreparedStatement = MockControl.createControl(PreparedStatement.class);
  1162. final PreparedStatement mockPreparedStatement = (PreparedStatement) ctrlPreparedStatement.getMock();
  1163. mockPreparedStatement.getWarnings();
  1164. ctrlPreparedStatement.setReturnValue(null);
  1165. mockPreparedStatement.close();
  1166. ctrlPreparedStatement.setVoidCallable();
  1167. MockControl ctrlPreparedStatement2 = MockControl.createControl(PreparedStatement.class);
  1168. final PreparedStatement mockPreparedStatement2 = (PreparedStatement) ctrlPreparedStatement2.getMock();
  1169. mockPreparedStatement2.executeQuery();
  1170. ctrlPreparedStatement2.setReturnValue(mockResultSet, 1);
  1172. MockControl ctrlCallableStatement = MockControl.createControl(CallableStatement.class);
  1173. final CallableStatement mockCallableStatement = (CallableStatement) ctrlCallableStatement.getMock();
  1174. mockCallableStatement.getWarnings();
  1175. ctrlCallableStatement.setReturnValue(null);
  1176. mockCallableStatement.close();
  1177. ctrlCallableStatement.setVoidCallable();
  1178. MockControl ctrlCallableStatement2 = MockControl.createControl(CallableStatement.class);
  1179. final CallableStatement mockCallableStatement2 = (CallableStatement) ctrlCallableStatement2.getMock();
  1180. mockCallableStatement2.execute();
  1181. ctrlCallableStatement2.setReturnValue(true);
  1182. mockCallableStatement2.getUpdateCount();
  1183. ctrlCallableStatement2.setReturnValue(-1);
  1184. mockCallableStatement2.getMoreResults();
  1185. ctrlCallableStatement2.setReturnValue(false);
  1186. mockCallableStatement2.getUpdateCount();
  1187. ctrlCallableStatement2.setReturnValue(-1);
  1189. ctrlResultSet.replay();
  1190. ctrlStatement.replay();
  1191. ctrlStatement2.replay();
  1192. ctrlPreparedStatement.replay();
  1193. ctrlPreparedStatement2.replay();
  1194. ctrlCallableStatement.replay();
  1195. ctrlCallableStatement2.replay();
  1197. mockConnection.createStatement();
  1198. ctrlConnection.setReturnValue(mockStatement, 1);
  1199. replay();
  1201. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1202. template.setNativeJdbcExtractor(new NativeJdbcExtractor() {
  1203. public boolean isNativeConnectionNecessaryForNativeStatements() {
  1204. return false;
  1205. }
  1206. public boolean isNativeConnectionNecessaryForNativePreparedStatements() {
  1207. return false;
  1208. }
  1209. public boolean isNativeConnectionNecessaryForNativeCallableStatements() {
  1210. return false;
  1211. }
  1212. public Connection getNativeConnection(Connection con) {
  1213. return con;
  1214. }
  1215. public Connection getNativeConnectionFromStatement(Statement stmt) throws SQLException {
  1216. return stmt.getConnection();
  1217. }
  1218. public Statement getNativeStatement(Statement stmt) {
  1219. assertTrue(stmt == mockStatement);
  1220. return mockStatement2;
  1221. }
  1222. public PreparedStatement getNativePreparedStatement(PreparedStatement ps) {
  1223. assertTrue(ps == mockPreparedStatement);
  1224. return mockPreparedStatement2;
  1225. }
  1226. public CallableStatement getNativeCallableStatement(CallableStatement cs) {
  1227. assertTrue(cs == mockCallableStatement);
  1228. return mockCallableStatement2;
  1229. }
  1230. public ResultSet getNativeResultSet(ResultSet rs) throws SQLException {
  1231. return rs;
  1232. }
  1233. });
  1235. template.query("my query", new ResultSetExtractor() {
  1236. public Object extractData(ResultSet rs2) throws SQLException {
  1237. assertEquals(mockResultSet, rs2);
  1238. return null;
  1239. }
  1240. });
  1242. template.query(new PreparedStatementCreator() {
  1243. public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
  1244. return mockPreparedStatement;
  1245. }
  1246. }, new ResultSetExtractor() {
  1247. public Object extractData(ResultSet rs2) throws SQLException {
  1248. assertEquals(mockResultSet, rs2);
  1249. return null;
  1250. }
  1251. });
  1253. template.call(new CallableStatementCreator() {
  1254. public CallableStatement createCallableStatement(Connection con) throws SQLException {
  1255. return mockCallableStatement;
  1256. }
  1257. },
  1258. new ArrayList());
  1260. ctrlStatement.verify();
  1261. ctrlStatement2.verify();
  1262. ctrlPreparedStatement.verify();
  1263. ctrlPreparedStatement2.verify();
  1264. ctrlCallableStatement.verify();
  1265. ctrlCallableStatement2.verify();
  1266. }
  1268. public void testStaticResultSetClosed() throws Exception {
  1269. MockControl ctrlResultSet;
  1270. ResultSet mockResultSet;
  1271. MockControl ctrlStatement;
  1272. Statement mockStatement;
  1273. MockControl ctrlResultSet2;
  1274. ResultSet mockResultSet2;
  1275. MockControl ctrlPreparedStatement;
  1276. PreparedStatement mockPreparedStatement;
  1278. try {
  1279. ctrlResultSet = MockControl.createControl(ResultSet.class);
  1280. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1281. mockResultSet.close();
  1282. ctrlResultSet.setVoidCallable();
  1284. ctrlStatement = MockControl.createControl(Statement.class);
  1285. mockStatement = (Statement) ctrlStatement.getMock();
  1286. mockStatement.executeQuery("my query");
  1287. ctrlStatement.setReturnValue(mockResultSet);
  1288. mockStatement.close();
  1289. ctrlStatement.setVoidCallable();
  1291. ctrlResultSet2 = MockControl.createControl(ResultSet.class);
  1292. mockResultSet2 = (ResultSet) ctrlResultSet2.getMock();
  1293. mockResultSet2.close();
  1294. ctrlResultSet2.setVoidCallable();
  1296. ctrlPreparedStatement = MockControl.createControl(PreparedStatement.class);
  1297. mockPreparedStatement = (PreparedStatement) ctrlPreparedStatement.getMock();
  1298. mockPreparedStatement.executeQuery();
  1299. ctrlPreparedStatement.setReturnValue(mockResultSet2);
  1300. mockPreparedStatement.close();
  1301. ctrlPreparedStatement.setVoidCallable();
  1303. mockConnection.createStatement();
  1304. ctrlConnection.setReturnValue(mockStatement);
  1305. mockConnection.prepareStatement("my query");
  1306. ctrlConnection.setReturnValue(mockPreparedStatement);
  1307. }
  1308. catch (SQLException sex) {
  1309. throw new RuntimeException("EasyMock initialization of jdbc objects failed");
  1310. }
  1312. ctrlResultSet.replay();
  1313. ctrlStatement.replay();
  1314. ctrlResultSet2.replay();
  1315. ctrlPreparedStatement.replay();
  1316. replay();
  1318. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1320. try {
  1321. template.query("my query", new ResultSetExtractor() {
  1322. public Object extractData(ResultSet rs) throws SQLException {
  1323. throw new InvalidDataAccessApiUsageException("");
  1324. }
  1325. });
  1326. fail("Should have thrown InvalidDataAccessApiUsageException");
  1327. }
  1328. catch (InvalidDataAccessApiUsageException idaauex) {
  1329. // ok
  1330. }
  1332. try {
  1333. template.query(new PreparedStatementCreator() {
  1334. public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
  1335. return con.prepareStatement("my query");
  1336. }
  1337. public String getSql() {
  1338. return null;
  1339. }
  1340. }, new ResultSetExtractor() {
  1341. public Object extractData(ResultSet rs2) throws SQLException {
  1342. throw new InvalidDataAccessApiUsageException("");
  1343. }
  1344. });
  1345. fail("Should have thrown InvalidDataAccessApiUsageException");
  1346. }
  1347. catch (InvalidDataAccessApiUsageException idaauex) {
  1348. // ok
  1349. }
  1351. // verify confirms if test is successful by checking if close() called
  1352. ctrlResultSet.verify();
  1353. ctrlStatement.verify();
  1354. ctrlResultSet2.verify();
  1355. ctrlPreparedStatement.verify();
  1356. }
  1358. public void testExecuteClosed() throws Exception {
  1359. MockControl ctrlResultSet;
  1360. ResultSet mockResultSet;
  1361. MockControl ctrlCallable;
  1362. CallableStatement mockCallable;
  1364. try {
  1365. ctrlResultSet = MockControl.createControl(ResultSet.class);
  1366. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1367. mockResultSet.next();
  1368. ctrlResultSet.setReturnValue(true);
  1369. mockResultSet.close();
  1370. ctrlResultSet.setVoidCallable();
  1372. ctrlCallable = MockControl.createControl(CallableStatement.class);
  1373. mockCallable = (CallableStatement) ctrlCallable.getMock();
  1374. mockCallable.execute();
  1375. ctrlCallable.setReturnValue(true);
  1376. mockCallable.getUpdateCount();
  1377. ctrlCallable.setReturnValue(-1);
  1378. mockCallable.getResultSet();
  1379. ctrlCallable.setReturnValue(mockResultSet);
  1380. mockCallable.close();
  1381. ctrlCallable.setVoidCallable();
  1383. mockConnection.prepareCall("my query");
  1384. ctrlConnection.setReturnValue(mockCallable);
  1386. }
  1387. catch (SQLException sex) {
  1388. throw new RuntimeException("EasyMock initialization of jdbc objects failed");
  1389. }
  1391. ctrlResultSet.replay();
  1392. ctrlCallable.replay();
  1393. replay();
  1395. List params = new ArrayList();
  1396. params.add(new SqlReturnResultSet("", new RowCallbackHandler() {
  1397. public void processRow(ResultSet rs) throws SQLException {
  1398. throw new InvalidDataAccessApiUsageException("");
  1399. }
  1401. }));
  1403. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1404. try {
  1405. template.call(new CallableStatementCreator() {
  1406. public CallableStatement createCallableStatement(Connection conn)
  1407. throws SQLException {
  1408. return conn.prepareCall("my query");
  1409. }
  1410. }, params);
  1411. }
  1412. catch (InvalidDataAccessApiUsageException idaauex) {
  1413. // ok
  1414. }
  1416. // verify confirms if test is successful by checking if close() called
  1417. ctrlResultSet.verify();
  1418. ctrlCallable.verify();
  1419. }
  1421. public void testQueryForList() throws Exception {
  1422. String sql = "SELECT AGE FROM CUSTMR WHERE ID < 3";
  1424. MockControl ctrlResultSetMetaData;
  1425. ResultSetMetaData mockResultSetMetaData;
  1426. MockControl ctrlResultSet;
  1427. ResultSet mockResultSet;
  1428. MockControl ctrlStatement;
  1429. Statement mockStatement;
  1431. try {
  1432. ctrlResultSetMetaData = MockControl.createControl(ResultSetMetaData.class);
  1433. mockResultSetMetaData = (ResultSetMetaData) ctrlResultSetMetaData.getMock();
  1434. mockResultSetMetaData.getColumnCount();
  1435. ctrlResultSetMetaData.setReturnValue(1);
  1436. mockResultSetMetaData.getColumnName(1);
  1437. ctrlResultSetMetaData.setReturnValue("age", 2);
  1439. ctrlResultSet = MockControl.createControl(ResultSet.class);
  1440. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1441. mockResultSet.getMetaData();
  1442. ctrlResultSet.setReturnValue(mockResultSetMetaData);
  1443. mockResultSet.next();
  1444. ctrlResultSet.setReturnValue(true);
  1445. mockResultSet.getObject(1);
  1446. ctrlResultSet.setReturnValue(new Integer(11));
  1447. mockResultSet.next();
  1448. ctrlResultSet.setReturnValue(true);
  1449. mockResultSet.getObject(1);
  1450. ctrlResultSet.setReturnValue(new Integer(12));
  1451. mockResultSet.next();
  1452. ctrlResultSet.setReturnValue(false);
  1453. mockResultSet.close();
  1454. ctrlResultSet.setVoidCallable();
  1456. ctrlStatement = MockControl.createControl(Statement.class);
  1457. mockStatement = (Statement) ctrlStatement.getMock();
  1458. mockStatement.executeQuery(sql);
  1459. ctrlStatement.setReturnValue(mockResultSet);
  1460. mockStatement.getWarnings();
  1461. ctrlStatement.setReturnValue(null);
  1462. mockStatement.close();
  1463. ctrlStatement.setVoidCallable();
  1465. mockConnection.createStatement();
  1466. ctrlConnection.setReturnValue(mockStatement);
  1467. }
  1468. catch (SQLException sex) {
  1469. throw new RuntimeException("EasyMock initialization of jdbc objects failed");
  1470. }
  1472. ctrlResultSetMetaData.replay();
  1473. ctrlResultSet.replay();
  1474. ctrlStatement.replay();
  1475. replay();
  1477. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1479. List li = template.queryForList(sql);
  1480. assertEquals("All rows returned", 2, li.size());
  1481. assertEquals("First row is Integer", 11, ((Integer)((Map)li.get(0)).get("age")).intValue());
  1482. assertEquals("Second row is Integer", 12, ((Integer)((Map)li.get(1)).get("age")).intValue());
  1484. ctrlResultSet.verify();
  1485. ctrlStatement.verify();
  1486. }
  1488. public void testQueryForListWithSingleRowAndColumn() throws Exception {
  1489. String sql = "SELECT AGE FROM CUSTMR WHERE ID < 3";
  1491. MockControl ctrlResultSetMetaData;
  1492. ResultSetMetaData mockResultSetMetaData;
  1493. MockControl ctrlResultSet;
  1494. ResultSet mockResultSet;
  1495. MockControl ctrlStatement;
  1496. Statement mockStatement;
  1498. try {
  1499. ctrlResultSetMetaData = MockControl.createControl(ResultSetMetaData.class);
  1500. mockResultSetMetaData = (ResultSetMetaData) ctrlResultSetMetaData.getMock();
  1501. mockResultSetMetaData.getColumnCount();
  1502. ctrlResultSetMetaData.setReturnValue(1);
  1503. mockResultSetMetaData.getColumnName(1);
  1504. ctrlResultSetMetaData.setReturnValue("age", 2);
  1506. ctrlResultSet = MockControl.createControl(ResultSet.class);
  1507. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1508. mockResultSet.getMetaData();
  1509. ctrlResultSet.setReturnValue(mockResultSetMetaData);
  1510. mockResultSet.next();
  1511. ctrlResultSet.setReturnValue(true);
  1512. mockResultSet.getObject(1);
  1513. ctrlResultSet.setReturnValue(new Integer(11));
  1514. mockResultSet.next();
  1515. ctrlResultSet.setReturnValue(false);
  1516. mockResultSet.close();
  1517. ctrlResultSet.setVoidCallable();
  1519. ctrlStatement = MockControl.createControl(Statement.class);
  1520. mockStatement = (Statement) ctrlStatement.getMock();
  1521. mockStatement.executeQuery(sql);
  1522. ctrlStatement.setReturnValue(mockResultSet);
  1523. mockStatement.getWarnings();
  1524. ctrlStatement.setReturnValue(null);
  1525. mockStatement.close();
  1526. ctrlStatement.setVoidCallable();
  1528. mockConnection.createStatement();
  1529. ctrlConnection.setReturnValue(mockStatement);
  1530. }
  1531. catch (SQLException sex) {
  1532. throw new RuntimeException("EasyMock initialization of jdbc objects failed");
  1533. }
  1535. ctrlResultSetMetaData.replay();
  1536. ctrlResultSet.replay();
  1537. ctrlStatement.replay();
  1538. replay();
  1540. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1542. List li = template.queryForList(sql);
  1543. assertEquals("All rows returned", 1, li.size());
  1544. assertEquals("First row is Integer", 11, ((Integer)((Map)li.get(0)).get("age")).intValue());
  1546. ctrlResultSet.verify();
  1547. ctrlStatement.verify();
  1548. }
  1550. public void testQueryForObject() throws Exception {
  1551. String sql = "SELECT AGE FROM CUSTMR WHERE ID = 3";
  1553. MockControl ctrlResultSetMetaData;
  1554. ResultSetMetaData mockResultSetMetaData;
  1555. MockControl ctrlResultSet;
  1556. ResultSet mockResultSet;
  1557. MockControl ctrlStatement;
  1558. Statement mockStatement;
  1560. try {
  1561. ctrlResultSetMetaData = MockControl.createControl(ResultSetMetaData.class);
  1562. mockResultSetMetaData = (ResultSetMetaData) ctrlResultSetMetaData.getMock();
  1563. mockResultSetMetaData.getColumnCount();
  1564. ctrlResultSetMetaData.setReturnValue(1);
  1566. ctrlResultSet = MockControl.createControl(ResultSet.class);
  1567. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1568. mockResultSet.getMetaData();
  1569. ctrlResultSet.setReturnValue(mockResultSetMetaData);
  1570. mockResultSet.next();
  1571. ctrlResultSet.setReturnValue(true);
  1572. mockResultSet.getObject(1);
  1573. ctrlResultSet.setReturnValue(new Integer(22));
  1574. mockResultSet.next();
  1575. ctrlResultSet.setReturnValue(false);
  1576. mockResultSet.close();
  1577. ctrlResultSet.setVoidCallable();
  1579. ctrlStatement = MockControl.createControl(Statement.class);
  1580. mockStatement = (Statement) ctrlStatement.getMock();
  1581. mockStatement.executeQuery(sql);
  1582. ctrlStatement.setReturnValue(mockResultSet);
  1583. mockStatement.getWarnings();
  1584. ctrlStatement.setReturnValue(null);
  1585. mockStatement.close();
  1586. ctrlStatement.setVoidCallable();
  1588. mockConnection.createStatement();
  1589. ctrlConnection.setReturnValue(mockStatement);
  1590. }
  1591. catch (SQLException sex) {
  1592. throw new RuntimeException("EasyMock initialization of jdbc objects failed");
  1593. }
  1595. ctrlResultSetMetaData.replay();
  1596. ctrlResultSet.replay();
  1597. ctrlStatement.replay();
  1598. replay();
  1600. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1602. Object o = template.queryForObject(sql, Integer.class);
  1603. assertEquals("Return of an object", "java.lang.Integer", o.getClass().getName());
  1605. ctrlResultSet.verify();
  1606. ctrlStatement.verify();
  1607. }
  1609. public void testQueryForInt() throws Exception {
  1610. String sql = "SELECT AGE FROM CUSTMR WHERE ID = 3";
  1612. MockControl ctrlResultSetMetaData;
  1613. ResultSetMetaData mockResultSetMetaData;
  1614. MockControl ctrlResultSet;
  1615. ResultSet mockResultSet;
  1616. MockControl ctrlStatement;
  1617. Statement mockStatement;
  1619. try {
  1620. ctrlResultSetMetaData = MockControl.createControl(ResultSetMetaData.class);
  1621. mockResultSetMetaData = (ResultSetMetaData) ctrlResultSetMetaData.getMock();
  1622. mockResultSetMetaData.getColumnCount();
  1623. ctrlResultSetMetaData.setReturnValue(1);
  1625. ctrlResultSet = MockControl.createControl(ResultSet.class);
  1626. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1627. mockResultSet.getMetaData();
  1628. ctrlResultSet.setReturnValue(mockResultSetMetaData);
  1629. mockResultSet.next();
  1630. ctrlResultSet.setReturnValue(true);
  1631. mockResultSet.getObject(1);
  1632. ctrlResultSet.setReturnValue(new Integer(22));
  1633. mockResultSet.next();
  1634. ctrlResultSet.setReturnValue(false);
  1635. mockResultSet.close();
  1636. ctrlResultSet.setVoidCallable();
  1638. ctrlStatement = MockControl.createControl(Statement.class);
  1639. mockStatement = (Statement) ctrlStatement.getMock();
  1640. mockStatement.executeQuery(sql);
  1641. ctrlStatement.setReturnValue(mockResultSet);
  1642. mockStatement.getWarnings();
  1643. ctrlStatement.setReturnValue(null);
  1644. mockStatement.close();
  1645. ctrlStatement.setVoidCallable();
  1647. mockConnection.createStatement();
  1648. ctrlConnection.setReturnValue(mockStatement);
  1649. }
  1650. catch (SQLException sex) {
  1651. throw new RuntimeException("EasyMock initialization of jdbc objects failed");
  1652. }
  1654. ctrlResultSetMetaData.replay();
  1655. ctrlResultSet.replay();
  1656. ctrlStatement.replay();
  1657. replay();
  1659. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1660. int i = template.queryForInt(sql);
  1661. assertEquals("Return of an int", 22, i);
  1663. ctrlResultSet.verify();
  1664. ctrlStatement.verify();
  1665. }
  1667. public void testQueryForLong() throws Exception {
  1668. String sql = "SELECT AGE FROM CUSTMR WHERE ID = 3";
  1670. MockControl ctrlResultSetMetaData;
  1671. ResultSetMetaData mockResultSetMetaData;
  1672. MockControl ctrlResultSet;
  1673. ResultSet mockResultSet;
  1674. MockControl ctrlStatement;
  1675. Statement mockStatement;
  1677. try {
  1678. ctrlResultSetMetaData = MockControl.createControl(ResultSetMetaData.class);
  1679. mockResultSetMetaData = (ResultSetMetaData) ctrlResultSetMetaData.getMock();
  1680. mockResultSetMetaData.getColumnCount();
  1681. ctrlResultSetMetaData.setReturnValue(1);
  1683. ctrlResultSet = MockControl.createControl(ResultSet.class);
  1684. mockResultSet = (ResultSet) ctrlResultSet.getMock();
  1685. mockResultSet.getMetaData();
  1686. ctrlResultSet.setReturnValue(mockResultSetMetaData);
  1687. mockResultSet.next();
  1688. ctrlResultSet.setReturnValue(true);
  1689. mockResultSet.getObject(1);
  1690. ctrlResultSet.setReturnValue(new java.math.BigDecimal(87));
  1691. mockResultSet.next();
  1692. ctrlResultSet.setReturnValue(false);
  1693. mockResultSet.close();
  1694. ctrlResultSet.setVoidCallable();
  1696. ctrlStatement = MockControl.createControl(Statement.class);
  1697. mockStatement = (Statement) ctrlStatement.getMock();
  1698. mockStatement.executeQuery(sql);
  1699. ctrlStatement.setReturnValue(mockResultSet);
  1700. mockStatement.getWarnings();
  1701. ctrlStatement.setReturnValue(null);
  1702. mockStatement.close();
  1703. ctrlStatement.setVoidCallable();
  1705. mockConnection.createStatement();
  1706. ctrlConnection.setReturnValue(mockStatement);
  1707. }
  1708. catch (SQLException sex) {
  1709. throw new RuntimeException("EasyMock initialization of jdbc objects failed");
  1710. }
  1712. ctrlResultSetMetaData.replay();
  1713. ctrlResultSet.replay();
  1714. ctrlStatement.replay();
  1715. replay();
  1717. JdbcTemplate template = new JdbcTemplate(mockDataSource);
  1718. long l = template.queryForLong(sql);
  1719. assertEquals("Return of a long", 87, l);
  1721. ctrlResultSet.verify();
  1722. ctrlStatement.verify();
  1723. }
  1726. private static interface JdbcTemplateCallback {
  1728. void doInJdbcTemplate(JdbcTemplate template, String sql, RowCallbackHandler rch);
  1729. }
  1732. private static class Dispatcher implements PreparedStatementCreator, SqlProvider {
  1734. private int id;
  1735. private String sql;
  1737. public Dispatcher(int id, String sql) {
  1738. this.id = id;
  1739. this.sql = sql;
  1740. }
  1742. public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
  1743. PreparedStatement ps = conn.prepareStatement(sql);
  1744. ps.setInt(1, id);
  1745. return ps;
  1746. }
  1748. public String getSql() {
  1749. return sql;
  1750. }
  1751. }
  1753. }