1 package org.springframework.jdbc.core.simple; 2 3 import junit.framework.TestCase; 4 import org.springframework.jdbc.core.metadata.TableMetaDataContext; 5 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource; 6 import org.springframework.jdbc.core.SqlParameterValue; 7 import org.easymock.MockControl; 8 9 import javax.sql.DataSource; 10 import java.util.Date; 11 import java.util.List; 12 import java.util.ArrayList; 13 import java.sql.Types; 14 import java.sql.DatabaseMetaData; 15 import java.sql.Connection; 16 import java.sql.ResultSet; 17 18 /** 19 * Mock object based tests for TableMetaDataContext. 20 * 21 * @author Thomas Risberg 22 */ 23 public class TableMetaDataContextTests extends TestCase { 24 private MockControl ctrlDataSource; 25 private DataSource mockDataSource; 26 private MockControl ctrlConnection; 27 private Connection mockConnection; 28 private MockControl ctrlDatabaseMetaData; 29 private DatabaseMetaData mockDatabaseMetaData; 30 31 private TableMetaDataContext context = new TableMetaDataContext(); 32 setUp()33 protected void setUp() throws Exception { 34 super.setUp(); 35 36 ctrlDatabaseMetaData = MockControl.createControl(DatabaseMetaData.class); 37 mockDatabaseMetaData = (DatabaseMetaData) ctrlDatabaseMetaData.getMock(); 38 39 ctrlConnection = MockControl.createControl(Connection.class); 40 mockConnection = (Connection) ctrlConnection.getMock(); 41 mockConnection.getMetaData(); 42 ctrlConnection.setDefaultReturnValue(mockDatabaseMetaData); 43 mockConnection.close(); 44 ctrlConnection.setDefaultVoidCallable(); 45 46 ctrlDataSource = MockControl.createControl(DataSource.class); 47 mockDataSource = (DataSource) ctrlDataSource.getMock(); 48 mockDataSource.getConnection(); 49 ctrlDataSource.setDefaultReturnValue(mockConnection); 50 51 } 52 tearDown()53 protected void tearDown() throws Exception { 54 super.tearDown(); 55 ctrlDatabaseMetaData.verify(); 56 ctrlDataSource.verify(); 57 } 58 replay()59 protected void replay() { 60 ctrlDatabaseMetaData.replay(); 61 ctrlConnection.replay(); 62 ctrlDataSource.replay(); 63 } 64 testMatchInParametersAndSqlTypeInfoWrapping()65 public void testMatchInParametersAndSqlTypeInfoWrapping() throws Exception { 66 final String TABLE = "customers"; 67 final String USER = "me"; 68 69 MockControl ctrlMetaDataResultSet = MockControl.createControl(ResultSet.class); 70 ResultSet mockMetaDataResultSet = (ResultSet) ctrlMetaDataResultSet.getMock(); 71 mockMetaDataResultSet.next(); 72 ctrlMetaDataResultSet.setReturnValue(true); 73 mockMetaDataResultSet.getString("TABLE_CAT"); 74 ctrlMetaDataResultSet.setReturnValue(null); 75 mockMetaDataResultSet.getString("TABLE_SCHEM"); 76 ctrlMetaDataResultSet.setReturnValue(USER); 77 mockMetaDataResultSet.getString("TABLE_NAME"); 78 ctrlMetaDataResultSet.setReturnValue(TABLE); 79 mockMetaDataResultSet.getString("TABLE_TYPE"); 80 ctrlMetaDataResultSet.setReturnValue("TABLE"); 81 mockMetaDataResultSet.next(); 82 ctrlMetaDataResultSet.setReturnValue(false); 83 mockMetaDataResultSet.close(); 84 ctrlMetaDataResultSet.setVoidCallable(); 85 86 MockControl ctrlColumnsResultSet = MockControl.createControl(ResultSet.class); 87 ResultSet mockColumnsResultSet = (ResultSet) ctrlColumnsResultSet.getMock(); 88 mockColumnsResultSet.next(); 89 ctrlColumnsResultSet.setReturnValue(true); 90 mockColumnsResultSet.getString("COLUMN_NAME"); 91 ctrlColumnsResultSet.setReturnValue("id"); 92 mockColumnsResultSet.getInt("DATA_TYPE"); 93 ctrlColumnsResultSet.setReturnValue(Types.INTEGER); 94 mockColumnsResultSet.getBoolean("NULLABLE"); 95 ctrlColumnsResultSet.setReturnValue(false); 96 mockColumnsResultSet.next(); 97 ctrlColumnsResultSet.setReturnValue(true); 98 mockColumnsResultSet.getString("COLUMN_NAME"); 99 ctrlColumnsResultSet.setReturnValue("name"); 100 mockColumnsResultSet.getInt("DATA_TYPE"); 101 ctrlColumnsResultSet.setReturnValue(Types.VARCHAR); 102 mockColumnsResultSet.getBoolean("NULLABLE"); 103 ctrlColumnsResultSet.setReturnValue(true); 104 mockColumnsResultSet.next(); 105 ctrlColumnsResultSet.setReturnValue(true); 106 mockColumnsResultSet.getString("COLUMN_NAME"); 107 ctrlColumnsResultSet.setReturnValue("customersince"); 108 mockColumnsResultSet.getInt("DATA_TYPE"); 109 ctrlColumnsResultSet.setReturnValue(Types.DATE); 110 mockColumnsResultSet.getBoolean("NULLABLE"); 111 ctrlColumnsResultSet.setReturnValue(true); 112 mockColumnsResultSet.next(); 113 ctrlColumnsResultSet.setReturnValue(true); 114 mockColumnsResultSet.getString("COLUMN_NAME"); 115 ctrlColumnsResultSet.setReturnValue("version"); 116 mockColumnsResultSet.getInt("DATA_TYPE"); 117 ctrlColumnsResultSet.setReturnValue(Types.NUMERIC); 118 mockColumnsResultSet.getBoolean("NULLABLE"); 119 ctrlColumnsResultSet.setReturnValue(false); 120 mockColumnsResultSet.next(); 121 ctrlColumnsResultSet.setReturnValue(false); 122 mockColumnsResultSet.close(); 123 ctrlColumnsResultSet.setVoidCallable(); 124 125 mockDatabaseMetaData.getDatabaseProductName(); 126 ctrlDatabaseMetaData.setReturnValue("MyDB"); 127 mockDatabaseMetaData.supportsGetGeneratedKeys(); 128 ctrlDatabaseMetaData.setReturnValue(false); 129 mockDatabaseMetaData.getDatabaseProductName(); 130 ctrlDatabaseMetaData.setReturnValue("MyDB"); 131 mockDatabaseMetaData.getDatabaseProductVersion(); 132 ctrlDatabaseMetaData.setReturnValue("1.0"); 133 mockDatabaseMetaData.getUserName(); 134 ctrlDatabaseMetaData.setReturnValue(USER); 135 mockDatabaseMetaData.storesUpperCaseIdentifiers(); 136 ctrlDatabaseMetaData.setReturnValue(false); 137 mockDatabaseMetaData.storesLowerCaseIdentifiers(); 138 ctrlDatabaseMetaData.setReturnValue(true); 139 mockDatabaseMetaData.getTables(null, null, TABLE, null); 140 ctrlDatabaseMetaData.setReturnValue(mockMetaDataResultSet); 141 mockDatabaseMetaData.getColumns(null, USER, TABLE, null); 142 ctrlDatabaseMetaData.setReturnValue(mockColumnsResultSet); 143 144 ctrlMetaDataResultSet.replay(); 145 ctrlColumnsResultSet.replay(); 146 replay(); 147 148 MapSqlParameterSource map = new MapSqlParameterSource(); 149 map.addValue("id", 1); 150 map.addValue("name", "Sven"); 151 map.addValue("customersince", new Date()); 152 map.addValue("version", 0); 153 map.registerSqlType("customersince", Types.DATE); 154 map.registerSqlType("version", Types.NUMERIC); 155 156 context.setTableName(TABLE); 157 context.processMetaData(mockDataSource, new ArrayList<String>(), new String[] {}); 158 159 List<Object> values = context.matchInParameterValuesWithInsertColumns(map); 160 161 assertEquals("wrong number of parameters: ", 4, values.size()); 162 assertTrue("id not wrapped with type info", values.get(0) instanceof Number); 163 assertTrue("name not wrapped with type info", values.get(1) instanceof String); 164 assertTrue("date wrapped with type info", values.get(2) instanceof SqlParameterValue); 165 assertTrue("version wrapped with type info", values.get(3) instanceof SqlParameterValue); 166 } 167 testTableWithSingleColumnGeneratedKey()168 public void testTableWithSingleColumnGeneratedKey() throws Exception { 169 final String TABLE = "customers"; 170 final String USER = "me"; 171 172 MockControl ctrlMetaDataResultSet = MockControl.createControl(ResultSet.class); 173 ResultSet mockMetaDataResultSet = (ResultSet) ctrlMetaDataResultSet.getMock(); 174 mockMetaDataResultSet.next(); 175 ctrlMetaDataResultSet.setReturnValue(true); 176 mockMetaDataResultSet.getString("TABLE_CAT"); 177 ctrlMetaDataResultSet.setReturnValue(null); 178 mockMetaDataResultSet.getString("TABLE_SCHEM"); 179 ctrlMetaDataResultSet.setReturnValue(USER); 180 mockMetaDataResultSet.getString("TABLE_NAME"); 181 ctrlMetaDataResultSet.setReturnValue(TABLE); 182 mockMetaDataResultSet.getString("TABLE_TYPE"); 183 ctrlMetaDataResultSet.setReturnValue("TABLE"); 184 mockMetaDataResultSet.next(); 185 ctrlMetaDataResultSet.setReturnValue(false); 186 mockMetaDataResultSet.close(); 187 ctrlMetaDataResultSet.setVoidCallable(); 188 189 MockControl ctrlColumnsResultSet = MockControl.createControl(ResultSet.class); 190 ResultSet mockColumnsResultSet = (ResultSet) ctrlColumnsResultSet.getMock(); 191 mockColumnsResultSet.next(); 192 ctrlColumnsResultSet.setReturnValue(true); 193 mockColumnsResultSet.getString("COLUMN_NAME"); 194 ctrlColumnsResultSet.setReturnValue("id"); 195 mockColumnsResultSet.getInt("DATA_TYPE"); 196 ctrlColumnsResultSet.setReturnValue(Types.INTEGER); 197 mockColumnsResultSet.getBoolean("NULLABLE"); 198 ctrlColumnsResultSet.setReturnValue(false); 199 mockColumnsResultSet.next(); 200 ctrlColumnsResultSet.setReturnValue(false); 201 mockColumnsResultSet.close(); 202 ctrlColumnsResultSet.setVoidCallable(); 203 204 mockDatabaseMetaData.getDatabaseProductName(); 205 ctrlDatabaseMetaData.setReturnValue("MyDB"); 206 mockDatabaseMetaData.supportsGetGeneratedKeys(); 207 ctrlDatabaseMetaData.setReturnValue(false); 208 mockDatabaseMetaData.getDatabaseProductName(); 209 ctrlDatabaseMetaData.setReturnValue("MyDB"); 210 mockDatabaseMetaData.getDatabaseProductVersion(); 211 ctrlDatabaseMetaData.setReturnValue("1.0"); 212 mockDatabaseMetaData.getUserName(); 213 ctrlDatabaseMetaData.setReturnValue(USER); 214 mockDatabaseMetaData.storesUpperCaseIdentifiers(); 215 ctrlDatabaseMetaData.setReturnValue(false); 216 mockDatabaseMetaData.storesLowerCaseIdentifiers(); 217 ctrlDatabaseMetaData.setReturnValue(true); 218 mockDatabaseMetaData.getTables(null, null, TABLE, null); 219 ctrlDatabaseMetaData.setReturnValue(mockMetaDataResultSet); 220 mockDatabaseMetaData.getColumns(null, USER, TABLE, null); 221 ctrlDatabaseMetaData.setReturnValue(mockColumnsResultSet); 222 223 ctrlMetaDataResultSet.replay(); 224 ctrlColumnsResultSet.replay(); 225 replay(); 226 227 MapSqlParameterSource map = new MapSqlParameterSource(); 228 229 String[] keyCols = new String[] {"id"}; 230 231 context.setTableName(TABLE); 232 context.processMetaData(mockDataSource, new ArrayList<String>(), keyCols); 233 234 List<Object> values = context.matchInParameterValuesWithInsertColumns(map); 235 236 String insertString = context.createInsertString(keyCols); 237 238 assertEquals("wrong number of parameters: ", 0, values.size()); 239 assertEquals("empty insert not generated correctly", "INSERT INTO customers () VALUES()", insertString); 240 } 241 } 242