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            return prepareStatement(sql);
189        }
190        
191        public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException
192        {
193            return prepareStatement(sql);
194        }
195        
196        public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException
197        {
198            return prepareStatement(sql);
199        }
200        
201        public void close() throws SQLException
202        {
203            closed = true;
204        }
205        
206        public boolean getAutoCommit() throws SQLException
207        {
208            return autoCommit;
209        }
210        
211        public String getCatalog() throws SQLException
212        {
213            return catalog;
214        }
215        
216        public int getHoldability() throws SQLException
217        {
218            return holdability;
219        }
220        
221        public DatabaseMetaData getMetaData() throws SQLException
222        {
223            return metaData;
224        }
225        
226        public int getTransactionIsolation() throws SQLException
227        {
228            return level;
229        }
230        
231        public Map getTypeMap() throws SQLException
232        {
233            return typeMap;
234        }
235        
236        public SQLWarning getWarnings() throws SQLException
237        {
238            return null;
239        }
240        
241        public boolean isClosed() throws SQLException
242        {
243            return closed;
244        }
245        
246        public boolean isReadOnly() throws SQLException
247        {
248            return readOnly;
249        }
250        
251        public String nativeSQL(String sql) throws SQLException
252        {
253            return sql;
254        }
255        
256        public void setAutoCommit(boolean autoCommit) throws SQLException
257        {
258            this.autoCommit = autoCommit;
259        }
260        
261        public void setCatalog(String catalog) throws SQLException
262        {
263            this.catalog = catalog;
264        }
265        
266        public void setHoldability(int holdability) throws SQLException
267        {
268            this.holdability = holdability;
269        }
270        
271        public void setReadOnly(boolean readOnly) throws SQLException
272        {
273            this.readOnly = readOnly;
274        }
275        
276        public Savepoint setSavepoint() throws SQLException
277        {
278            return setSavepoint("");
279        }
280        
281        public Savepoint setSavepoint(String name) throws SQLException
282        {
283            MockSavepoint savePoint = new MockSavepoint(name, savepointCount);
284            savepoints.put(new Integer(savePoint.getSavepointId()), savePoint);
285            savepointCount++;
286            return savePoint;
287        }
288        
289        public void setTransactionIsolation(int level) throws SQLException
290        {
291            this.level = level;
292        }
293        
294        public void setTypeMap(Map typeMap) throws SQLException
295        {
296            this.typeMap = typeMap;
297        }
298        
299        public void releaseSavepoint(Savepoint savepoint) throws SQLException
300        {
301            MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId()));
302            if(currentSavepoint.isReleased())
303            {
304                throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name " 
305                        + currentSavepoint.getSavepointName() + " is released");
306            }
307            currentSavepoint.setReleased(true);
308        }
309        
310        public void commit() throws SQLException
311        {
312            numberCommits++;
313        }
314        
315        public void rollback() throws SQLException
316        {
317            numberRollbacks++;
318        }
319        
320        public void rollback(Savepoint savepoint) throws SQLException
321        {
322            MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId()));
323            if(currentSavepoint.isReleased())
324            {
325                throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name " 
326                        + currentSavepoint.getSavepointName() + " is released");
327            }
328            currentSavepoint.setRolledBack(true);
329            numberRollbacks++;
330        }
331        
332        public void clearWarnings() throws SQLException
333        {
334            
335        }
336    }