001    package com.mockrunner.mock.jdbc;
002    
003    import java.sql.CallableStatement;
004    import java.sql.Connection;
005    import java.sql.DatabaseMetaData;
006    import java.sql.PreparedStatement;
007    import java.sql.ResultSet;
008    import java.sql.SQLException;
009    import java.sql.SQLWarning;
010    import java.sql.Savepoint;
011    import java.sql.Statement;
012    import java.util.Collections;
013    import java.util.HashMap;
014    import java.util.Map;
015    
016    import com.mockrunner.base.NestedApplicationException;
017    import com.mockrunner.jdbc.CallableStatementResultSetHandler;
018    import com.mockrunner.jdbc.PreparedStatementResultSetHandler;
019    import com.mockrunner.jdbc.StatementResultSetHandler;
020    
021    /**
022     * Mock implementation of <code>Connection</code>.
023     */
024    public class MockConnection implements Connection
025    {
026        private StatementResultSetHandler statementHandler;
027        private PreparedStatementResultSetHandler preparedStatementHandler;
028        private CallableStatementResultSetHandler callableStatementHandler;
029        private DatabaseMetaData metaData;
030        private Map savepoints;
031        private int savepointCount;
032        private boolean closed;
033        private boolean autoCommit;
034        private boolean readOnly;
035        private int holdability;
036        private int level;
037        private Map typeMap;
038        private String catalog ;
039        private int numberCommits;
040        private int numberRollbacks;
041        
042        public MockConnection()
043        {
044            statementHandler = new StatementResultSetHandler();
045            preparedStatementHandler = new PreparedStatementResultSetHandler();
046            callableStatementHandler = new CallableStatementResultSetHandler();
047            metaData = new MockDatabaseMetaData();
048            ((MockDatabaseMetaData)metaData).setConnection(this);
049            closed = false;
050            autoCommit = false;
051            readOnly = false;
052            holdability = ResultSet.HOLD_CURSORS_OVER_COMMIT;
053            try
054            {  
055                level = metaData.getDefaultTransactionIsolation();
056            }
057            catch(SQLException exc)
058            {
059                throw new NestedApplicationException(exc);
060            }
061            typeMap = new HashMap();
062            savepoints = new HashMap();
063            savepointCount = 0;
064            catalog = null;
065            numberCommits = 0;
066            numberRollbacks = 0;
067        }
068        
069        public void setMetaData(DatabaseMetaData metaData) throws SQLException
070        {
071            if(metaData != null && metaData instanceof MockDatabaseMetaData)
072            {
073                ((MockDatabaseMetaData)metaData).setConnection(this);
074            }
075            this.metaData = metaData;
076        }
077        
078        public int getNumberCommits()
079        {
080            return numberCommits;
081        }
082        
083        public int getNumberRollbacks()
084        {
085            return numberRollbacks;
086        }
087        
088        public Map getSavepointMap()
089        {
090            return Collections.unmodifiableMap(savepoints);
091        }
092        
093        public void resetNumberCommits()
094        {
095            numberCommits = 0;
096        }
097        
098        public void resetNumberRollbacks()
099        {
100            numberRollbacks = 0;
101        }
102        
103        public void resetSavepointMap()
104        {
105            savepoints.clear();
106        }
107        
108        public StatementResultSetHandler getStatementResultSetHandler()
109        {
110            return statementHandler;
111        }
112        
113        public PreparedStatementResultSetHandler getPreparedStatementResultSetHandler()
114        {
115            return preparedStatementHandler;
116        }
117        
118        public CallableStatementResultSetHandler getCallableStatementResultSetHandler()
119        {
120            return callableStatementHandler;
121        }
122        
123        public Statement createStatement() throws SQLException
124        {
125            MockStatement statement = new MockStatement(this);
126            getStatementResultSetHandler().addStatement(statement);
127            return statement;
128        }
129        
130        public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException
131        {
132            MockStatement statement = new MockStatement(this, resultSetType, resultSetConcurrency);
133            getStatementResultSetHandler().addStatement(statement);
134            return statement;
135        }
136        
137        public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
138        {
139            MockStatement statement = new MockStatement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
140            getStatementResultSetHandler().addStatement(statement);
141            return statement;
142        }
143        
144        public CallableStatement prepareCall(String sql) throws SQLException
145        {
146            MockCallableStatement statement = new MockCallableStatement(this, sql);
147            getCallableStatementResultSetHandler().addCallableStatement(statement);
148            return statement;
149        }
150        
151        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
152        {
153            MockCallableStatement statement = new MockCallableStatement(this, sql, resultSetType, resultSetConcurrency);
154            getCallableStatementResultSetHandler().addCallableStatement(statement);
155            return statement;
156        }
157        
158        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
159        {
160            MockCallableStatement statement = new MockCallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
161            getCallableStatementResultSetHandler().addCallableStatement(statement);
162            return statement;
163        }
164        
165        public PreparedStatement prepareStatement(String sql) throws SQLException
166        {
167            MockPreparedStatement statement = new MockPreparedStatement(this, sql);
168            getPreparedStatementResultSetHandler().addPreparedStatement(statement);
169            return statement;
170        }
171        
172        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
173        {
174            MockPreparedStatement statement = new MockPreparedStatement(this, sql, resultSetType, resultSetConcurrency);
175            getPreparedStatementResultSetHandler().addPreparedStatement(statement);
176            return statement;
177        }
178        
179        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
180        {
181            MockPreparedStatement statement = new MockPreparedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
182            getPreparedStatementResultSetHandler().addPreparedStatement(statement);
183            return statement;
184        }
185        
186        public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException
187        {
188            verifyAutoGeneratedKeysParameter(autoGeneratedKeys);
189            MockPreparedStatement statement = new MockPreparedStatement(this, sql, autoGeneratedKeys == Statement.RETURN_GENERATED_KEYS);;
190            getPreparedStatementResultSetHandler().addPreparedStatement(statement);
191            return statement;
192        }
193        
194        public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException
195        {
196            return prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
197        }
198        
199        public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException
200        {
201            return prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
202        }
203        
204        private void verifyAutoGeneratedKeysParameter(int autoGeneratedKeys) throws SQLException
205        {
206            if(Statement.RETURN_GENERATED_KEYS != autoGeneratedKeys && Statement.NO_GENERATED_KEYS != autoGeneratedKeys)
207            {
208                throw new SQLException("autoGeneratedKeys must be either Statement.RETURN_GENERATED_KEYS or Statement.NO_GENERATED_KEYS");
209            }
210        }
211        
212        public void close() throws SQLException
213        {
214            closed = true;
215        }
216        
217        public boolean getAutoCommit() throws SQLException
218        {
219            return autoCommit;
220        }
221        
222        public String getCatalog() throws SQLException
223        {
224            return catalog;
225        }
226        
227        public int getHoldability() throws SQLException
228        {
229            return holdability;
230        }
231        
232        public DatabaseMetaData getMetaData() throws SQLException
233        {
234            return metaData;
235        }
236        
237        public int getTransactionIsolation() throws SQLException
238        {
239            return level;
240        }
241        
242        public Map getTypeMap() throws SQLException
243        {
244            return typeMap;
245        }
246        
247        public SQLWarning getWarnings() throws SQLException
248        {
249            return null;
250        }
251        
252        public boolean isClosed() throws SQLException
253        {
254            return closed;
255        }
256        
257        public boolean isReadOnly() throws SQLException
258        {
259            return readOnly;
260        }
261        
262        public String nativeSQL(String sql) throws SQLException
263        {
264            return sql;
265        }
266        
267        public void setAutoCommit(boolean autoCommit) throws SQLException
268        {
269            this.autoCommit = autoCommit;
270        }
271        
272        public void setCatalog(String catalog) throws SQLException
273        {
274            this.catalog = catalog;
275        }
276        
277        public void setHoldability(int holdability) throws SQLException
278        {
279            this.holdability = holdability;
280        }
281        
282        public void setReadOnly(boolean readOnly) throws SQLException
283        {
284            this.readOnly = readOnly;
285        }
286        
287        public Savepoint setSavepoint() throws SQLException
288        {
289            return setSavepoint("");
290        }
291        
292        public Savepoint setSavepoint(String name) throws SQLException
293        {
294            MockSavepoint savePoint = new MockSavepoint(name, savepointCount);
295            savepoints.put(new Integer(savePoint.getSavepointId()), savePoint);
296            savepointCount++;
297            return savePoint;
298        }
299        
300        public void setTransactionIsolation(int level) throws SQLException
301        {
302            this.level = level;
303        }
304        
305        public void setTypeMap(Map typeMap) throws SQLException
306        {
307            this.typeMap = typeMap;
308        }
309        
310        public void releaseSavepoint(Savepoint savepoint) throws SQLException
311        {
312            MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId()));
313            if(currentSavepoint.isReleased())
314            {
315                throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name " 
316                        + currentSavepoint.getSavepointName() + " is released");
317            }
318            currentSavepoint.setReleased(true);
319        }
320        
321        public void commit() throws SQLException
322        {
323            numberCommits++;
324        }
325        
326        public void rollback() throws SQLException
327        {
328            numberRollbacks++;
329        }
330        
331        public void rollback(Savepoint savepoint) throws SQLException
332        {
333            MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId()));
334            if(currentSavepoint.isReleased())
335            {
336                throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name " + currentSavepoint.getSavepointName() + " is released");
337            }
338            currentSavepoint.setRolledBack(true);
339            numberRollbacks++;
340        }
341        
342        public void clearWarnings() throws SQLException
343        {
344            
345        }
346    }