1 16 17 package org.springframework.orm.hibernate3.support; 18 19 import java.io.ByteArrayInputStream ; 20 import java.io.ByteArrayOutputStream ; 21 import java.io.ObjectOutputStream ; 22 import java.io.Serializable ; 23 import java.sql.PreparedStatement ; 24 import java.sql.ResultSet ; 25 import java.sql.SQLException ; 26 import java.sql.Types ; 27 import java.util.Arrays ; 28 import java.util.List ; 29 30 import javax.transaction.Status ; 31 import javax.transaction.Synchronization ; 32 import javax.transaction.TransactionManager ; 33 34 import junit.framework.TestCase; 35 import org.easymock.ArgumentsMatcher; 36 import org.easymock.MockControl; 37 import org.hibernate.SessionFactory; 38 import org.hibernate.classic.Session; 39 40 import org.springframework.jdbc.support.lob.LobCreator; 41 import org.springframework.jdbc.support.lob.LobHandler; 42 import org.springframework.orm.hibernate3.SessionFactoryUtils; 43 import org.springframework.transaction.MockJtaTransaction; 44 import org.springframework.transaction.support.TransactionSynchronization; 45 import org.springframework.transaction.support.TransactionSynchronizationManager; 46 47 51 public class LobTypeTests extends TestCase { 52 53 private MockControl rsControl = MockControl.createControl(ResultSet .class); 54 private ResultSet rs = (ResultSet ) rsControl.getMock(); 55 private MockControl psControl = MockControl.createControl(PreparedStatement .class); 56 private PreparedStatement ps = (PreparedStatement ) psControl.getMock(); 57 58 private MockControl lobHandlerControl = MockControl.createControl(LobHandler.class); 59 private LobHandler lobHandler = (LobHandler) lobHandlerControl.getMock(); 60 private MockControl lobCreatorControl = MockControl.createControl(LobCreator.class); 61 private LobCreator lobCreator = (LobCreator) lobCreatorControl.getMock(); 62 63 protected void setUp() throws SQLException { 64 lobHandler.getLobCreator(); 65 lobHandlerControl.setReturnValue(lobCreator); 66 lobCreator.close(); 67 lobCreatorControl.setVoidCallable(1); 68 69 rsControl.replay(); 70 psControl.replay(); 71 } 72 73 public void testClobStringType() throws Exception { 74 lobHandler.getClobAsString(rs, "column"); 75 lobHandlerControl.setReturnValue("content"); 76 lobCreator.setClobAsString(ps, 1, "content"); 77 lobCreatorControl.setVoidCallable(1); 78 79 lobHandlerControl.replay(); 80 lobCreatorControl.replay(); 81 82 ClobStringType type = new ClobStringType(lobHandler, null); 83 assertEquals(1, type.sqlTypes().length); 84 assertEquals(Types.CLOB, type.sqlTypes()[0]); 85 assertEquals(String .class, type.returnedClass()); 86 assertTrue(type.equals("content", "content")); 87 assertEquals("content", type.deepCopy("content")); 88 assertFalse(type.isMutable()); 89 90 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 91 TransactionSynchronizationManager.initSynchronization(); 92 try { 93 type.nullSafeSet(ps, "content", 1); 94 List synchs = TransactionSynchronizationManager.getSynchronizations(); 95 assertEquals(1, synchs.size()); 96 assertTrue(synchs.get(0).getClass().getName().endsWith("SpringLobCreatorSynchronization")); 97 ((TransactionSynchronization) synchs.get(0)).beforeCompletion(); 98 ((TransactionSynchronization) synchs.get(0)).afterCompletion(TransactionSynchronization.STATUS_COMMITTED); 99 } 100 finally { 101 TransactionSynchronizationManager.clearSynchronization(); 102 } 103 } 104 105 public void testClobStringTypeWithSynchronizedSession() throws Exception { 106 MockControl sfControl = MockControl.createControl(SessionFactory.class); 107 SessionFactory sf = (SessionFactory) sfControl.getMock(); 108 MockControl sessionControl = MockControl.createControl(Session.class); 109 Session session = (Session) sessionControl.getMock(); 110 sf.openSession(); 111 sfControl.setReturnValue(session, 1); 112 session.getSessionFactory(); 113 sessionControl.setReturnValue(sf, 1); 114 session.close(); 115 sessionControl.setReturnValue(null, 1); 116 sfControl.replay(); 117 sessionControl.replay(); 118 119 lobHandler.getClobAsString(rs, "column"); 120 lobHandlerControl.setReturnValue("content"); 121 lobCreator.setClobAsString(ps, 1, "content"); 122 lobCreatorControl.setVoidCallable(1); 123 124 lobHandlerControl.replay(); 125 lobCreatorControl.replay(); 126 127 ClobStringType type = new ClobStringType(lobHandler, null); 128 assertEquals(1, type.sqlTypes().length); 129 assertEquals(Types.CLOB, type.sqlTypes()[0]); 130 assertEquals(String .class, type.returnedClass()); 131 assertTrue(type.equals("content", "content")); 132 assertEquals("content", type.deepCopy("content")); 133 assertFalse(type.isMutable()); 134 135 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 136 TransactionSynchronizationManager.initSynchronization(); 137 try { 138 SessionFactoryUtils.getSession(sf, true); 139 type.nullSafeSet(ps, "content", 1); 140 List synchs = TransactionSynchronizationManager.getSynchronizations(); 141 assertEquals(2, synchs.size()); 142 assertTrue(synchs.get(0).getClass().getName().endsWith("SpringLobCreatorSynchronization")); 143 ((TransactionSynchronization) synchs.get(0)).beforeCompletion(); 144 ((TransactionSynchronization) synchs.get(0)).afterCompletion(TransactionSynchronization.STATUS_COMMITTED); 145 ((TransactionSynchronization) synchs.get(1)).beforeCompletion(); 146 ((TransactionSynchronization) synchs.get(1)).afterCompletion(TransactionSynchronization.STATUS_COMMITTED); 147 } 148 finally { 149 TransactionSynchronizationManager.clearSynchronization(); 150 } 151 152 sfControl.verify(); 153 sessionControl.verify(); 154 } 155 156 public void testClobStringTypeWithFlushOnCommit() throws Exception { 157 lobHandler.getClobAsString(rs, "column"); 158 lobHandlerControl.setReturnValue("content"); 159 lobCreator.setClobAsString(ps, 1, "content"); 160 lobCreatorControl.setVoidCallable(1); 161 162 lobHandlerControl.replay(); 163 lobCreatorControl.replay(); 164 165 ClobStringType type = new ClobStringType(lobHandler, null); 166 assertEquals(1, type.sqlTypes().length); 167 assertEquals(Types.CLOB, type.sqlTypes()[0]); 168 assertEquals(String .class, type.returnedClass()); 169 assertTrue(type.equals("content", "content")); 170 assertEquals("content", type.deepCopy("content")); 171 assertFalse(type.isMutable()); 172 173 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 174 TransactionSynchronizationManager.initSynchronization(); 175 try { 176 type.nullSafeSet(ps, "content", 1); 177 List synchs = TransactionSynchronizationManager.getSynchronizations(); 178 assertEquals(1, synchs.size()); 179 ((TransactionSynchronization) synchs.get(0)).afterCompletion(TransactionSynchronization.STATUS_COMMITTED); 180 } 181 finally { 182 TransactionSynchronizationManager.clearSynchronization(); 183 } 184 } 185 186 public void testClobStringTypeWithJtaSynchronization() throws Exception { 187 MockControl tmControl = MockControl.createControl(TransactionManager .class); 188 TransactionManager tm = (TransactionManager ) tmControl.getMock(); 189 MockJtaTransaction transaction = new MockJtaTransaction(); 190 tm.getStatus(); 191 tmControl.setReturnValue(Status.STATUS_ACTIVE, 1); 192 tm.getTransaction(); 193 tmControl.setReturnValue(transaction, 1); 194 195 lobHandler.getClobAsString(rs, "column"); 196 lobHandlerControl.setReturnValue("content"); 197 lobCreator.setClobAsString(ps, 1, "content"); 198 lobCreatorControl.setVoidCallable(1); 199 200 lobHandlerControl.replay(); 201 lobCreatorControl.replay(); 202 203 ClobStringType type = new ClobStringType(lobHandler, tm); 204 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 205 tmControl.replay(); 206 type.nullSafeSet(ps, "content", 1); 207 Synchronization synch = transaction.getSynchronization(); 208 assertNotNull(synch); 209 synch.beforeCompletion(); 210 synch.afterCompletion(Status.STATUS_COMMITTED); 211 tmControl.verify(); 212 } 213 214 public void testClobStringTypeWithJtaSynchronizationAndRollback() throws Exception { 215 MockControl tmControl = MockControl.createControl(TransactionManager .class); 216 TransactionManager tm = (TransactionManager ) tmControl.getMock(); 217 MockJtaTransaction transaction = new MockJtaTransaction(); 218 tm.getStatus(); 219 tmControl.setReturnValue(Status.STATUS_ACTIVE, 1); 220 tm.getTransaction(); 221 tmControl.setReturnValue(transaction, 1); 222 223 lobHandler.getClobAsString(rs, "column"); 224 lobHandlerControl.setReturnValue("content"); 225 lobCreator.setClobAsString(ps, 1, "content"); 226 lobCreatorControl.setVoidCallable(1); 227 228 lobHandlerControl.replay(); 229 lobCreatorControl.replay(); 230 231 ClobStringType type = new ClobStringType(lobHandler, tm); 232 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 233 tmControl.replay(); 234 type.nullSafeSet(ps, "content", 1); 235 Synchronization synch = transaction.getSynchronization(); 236 assertNotNull(synch); 237 synch.afterCompletion(Status.STATUS_ROLLEDBACK); 238 tmControl.verify(); 239 } 240 241 public void testBlobByteArrayType() throws Exception { 242 byte[] content = "content".getBytes(); 243 lobHandler.getBlobAsBytes(rs, "column"); 244 lobHandlerControl.setReturnValue(content); 245 lobCreator.setBlobAsBytes(ps, 1, content); 246 lobCreatorControl.setVoidCallable(1); 247 248 lobHandlerControl.replay(); 249 lobCreatorControl.replay(); 250 251 BlobByteArrayType type = new BlobByteArrayType(lobHandler, null); 252 assertEquals(1, type.sqlTypes().length); 253 assertEquals(Types.BLOB, type.sqlTypes()[0]); 254 assertEquals(byte[].class, type.returnedClass()); 255 assertTrue(type.equals(new byte[] {(byte) 255}, new byte[] {(byte) 255})); 256 assertTrue(Arrays.equals(new byte[] {(byte) 255}, (byte[]) type.deepCopy(new byte[] {(byte) 255}))); 257 assertTrue(type.isMutable()); 258 259 assertEquals(content, type.nullSafeGet(rs, new String [] {"column"}, null)); 260 TransactionSynchronizationManager.initSynchronization(); 261 try { 262 type.nullSafeSet(ps, content, 1); 263 List synchs = TransactionSynchronizationManager.getSynchronizations(); 264 assertEquals(1, synchs.size()); 265 ((TransactionSynchronization) synchs.get(0)).beforeCompletion(); 266 ((TransactionSynchronization) synchs.get(0)).afterCompletion(TransactionSynchronization.STATUS_COMMITTED); 267 } 268 finally { 269 TransactionSynchronizationManager.clearSynchronization(); 270 } 271 } 272 273 public void testBlobByteArrayTypeWithJtaSynchronization() throws Exception { 274 MockControl tmControl = MockControl.createControl(TransactionManager .class); 275 TransactionManager tm = (TransactionManager ) tmControl.getMock(); 276 MockJtaTransaction transaction = new MockJtaTransaction(); 277 tm.getStatus(); 278 tmControl.setReturnValue(Status.STATUS_ACTIVE, 1); 279 tm.getTransaction(); 280 tmControl.setReturnValue(transaction, 1); 281 282 byte[] content = "content".getBytes(); 283 lobHandler.getBlobAsBytes(rs, "column"); 284 lobHandlerControl.setReturnValue(content); 285 lobCreator.setBlobAsBytes(ps, 1, content); 286 lobCreatorControl.setVoidCallable(1); 287 288 lobHandlerControl.replay(); 289 lobCreatorControl.replay(); 290 291 BlobByteArrayType type = new BlobByteArrayType(lobHandler, tm); 292 assertEquals(content, type.nullSafeGet(rs, new String [] {"column"}, null)); 293 tmControl.replay(); 294 type.nullSafeSet(ps, content, 1); 295 Synchronization synch = transaction.getSynchronization(); 296 assertNotNull(synch); 297 synch.beforeCompletion(); 298 synch.afterCompletion(Status.STATUS_COMMITTED); 299 tmControl.verify(); 300 } 301 302 public void testBlobByteArrayTypeWithJtaSynchronizationAndRollback() throws Exception { 303 MockControl tmControl = MockControl.createControl(TransactionManager .class); 304 TransactionManager tm = (TransactionManager ) tmControl.getMock(); 305 MockJtaTransaction transaction = new MockJtaTransaction(); 306 tm.getStatus(); 307 tmControl.setReturnValue(Status.STATUS_ACTIVE, 1); 308 tm.getTransaction(); 309 tmControl.setReturnValue(transaction, 1); 310 311 byte[] content = "content".getBytes(); 312 lobHandler.getBlobAsBytes(rs, "column"); 313 lobHandlerControl.setReturnValue(content); 314 lobCreator.setBlobAsBytes(ps, 1, content); 315 lobCreatorControl.setVoidCallable(1); 316 317 lobHandlerControl.replay(); 318 lobCreatorControl.replay(); 319 320 BlobByteArrayType type = new BlobByteArrayType(lobHandler, tm); 321 assertEquals(content, type.nullSafeGet(rs, new String [] {"column"}, null)); 322 tmControl.replay(); 323 type.nullSafeSet(ps, content, 1); 324 Synchronization synch = transaction.getSynchronization(); 325 assertNotNull(synch); 326 synch.afterCompletion(Status.STATUS_ROLLEDBACK); 327 tmControl.verify(); 328 } 329 330 public void testBlobSerializableType() throws Exception { 331 ByteArrayOutputStream baos = new ByteArrayOutputStream (); 332 ObjectOutputStream oos = new ObjectOutputStream (baos); 333 oos.writeObject("content"); 334 oos.close(); 335 336 lobHandler.getBlobAsBinaryStream(rs, "column"); 337 lobHandlerControl.setReturnValue(new ByteArrayInputStream (baos.toByteArray())); 338 lobCreator.setBlobAsBytes(ps, 1, baos.toByteArray()); 339 lobCreatorControl.setMatcher(new ArgumentsMatcher() { 340 public boolean matches(Object [] o1, Object [] o2) { 341 return Arrays.equals((byte[]) o1[2], (byte[]) o2[2]); 342 } 343 public String toString(Object [] objects) { 344 return null; 345 } 346 }); 347 348 lobHandlerControl.replay(); 349 lobCreatorControl.replay(); 350 351 BlobSerializableType type = new BlobSerializableType(lobHandler, null); 352 assertEquals(1, type.sqlTypes().length); 353 assertEquals(Types.BLOB, type.sqlTypes()[0]); 354 assertEquals(Serializable .class, type.returnedClass()); 355 assertTrue(type.isMutable()); 356 357 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 358 TransactionSynchronizationManager.initSynchronization(); 359 try { 360 type.nullSafeSet(ps, "content", 1); 361 List synchs = TransactionSynchronizationManager.getSynchronizations(); 362 assertEquals(1, synchs.size()); 363 ((TransactionSynchronization) synchs.get(0)).beforeCompletion(); 364 ((TransactionSynchronization) synchs.get(0)).afterCompletion(TransactionSynchronization.STATUS_COMMITTED); 365 } 366 finally { 367 TransactionSynchronizationManager.clearSynchronization(); 368 } 369 } 370 371 public void testBlobSerializableTypeWithNull() throws Exception { 372 lobHandler.getBlobAsBinaryStream(rs, "column"); 373 lobHandlerControl.setReturnValue(null); 374 lobCreator.setBlobAsBytes(ps, 1, null); 375 376 lobHandlerControl.replay(); 377 lobCreatorControl.replay(); 378 379 BlobSerializableType type = new BlobSerializableType(lobHandler, null); 380 assertEquals(null, type.nullSafeGet(rs, new String [] {"column"}, null)); 381 TransactionSynchronizationManager.initSynchronization(); 382 try { 383 type.nullSafeSet(ps, null, 1); 384 List synchs = TransactionSynchronizationManager.getSynchronizations(); 385 assertEquals(1, synchs.size()); 386 ((TransactionSynchronization) synchs.get(0)).beforeCompletion(); 387 } 388 finally { 389 TransactionSynchronizationManager.clearSynchronization(); 390 } 391 } 392 393 public void testBlobSerializableTypeWithJtaSynchronization() throws Exception { 394 MockControl tmControl = MockControl.createControl(TransactionManager .class); 395 TransactionManager tm = (TransactionManager ) tmControl.getMock(); 396 MockJtaTransaction transaction = new MockJtaTransaction(); 397 tm.getStatus(); 398 tmControl.setReturnValue(Status.STATUS_ACTIVE, 1); 399 tm.getTransaction(); 400 tmControl.setReturnValue(transaction, 1); 401 402 ByteArrayOutputStream baos = new ByteArrayOutputStream (); 403 ObjectOutputStream oos = new ObjectOutputStream (baos); 404 oos.writeObject("content"); 405 oos.close(); 406 407 lobHandler.getBlobAsBinaryStream(rs, "column"); 408 lobHandlerControl.setReturnValue(new ByteArrayInputStream (baos.toByteArray())); 409 lobCreator.setBlobAsBytes(ps, 1, baos.toByteArray()); 410 lobCreatorControl.setMatcher(new ArgumentsMatcher() { 411 public boolean matches(Object [] o1, Object [] o2) { 412 return Arrays.equals((byte[]) o1[2], (byte[]) o2[2]); 413 } 414 public String toString(Object [] objects) { 415 return null; 416 } 417 }); 418 419 lobHandlerControl.replay(); 420 lobCreatorControl.replay(); 421 422 BlobSerializableType type = new BlobSerializableType(lobHandler, tm); 423 assertEquals(1, type.sqlTypes().length); 424 assertEquals(Types.BLOB, type.sqlTypes()[0]); 425 assertEquals(Serializable .class, type.returnedClass()); 426 assertTrue(type.isMutable()); 427 428 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 429 tmControl.replay(); 430 type.nullSafeSet(ps, "content", 1); 431 Synchronization synch = transaction.getSynchronization(); 432 assertNotNull(synch); 433 synch.beforeCompletion(); 434 synch.afterCompletion(Status.STATUS_COMMITTED); 435 tmControl.verify(); 436 } 437 438 public void testBlobSerializableTypeWithJtaSynchronizationAndRollback() throws Exception { 439 MockControl tmControl = MockControl.createControl(TransactionManager .class); 440 TransactionManager tm = (TransactionManager ) tmControl.getMock(); 441 MockJtaTransaction transaction = new MockJtaTransaction(); 442 tm.getStatus(); 443 tmControl.setReturnValue(Status.STATUS_ACTIVE, 1); 444 tm.getTransaction(); 445 tmControl.setReturnValue(transaction, 1); 446 447 ByteArrayOutputStream baos = new ByteArrayOutputStream (); 448 ObjectOutputStream oos = new ObjectOutputStream (baos); 449 oos.writeObject("content"); 450 oos.close(); 451 452 lobHandler.getBlobAsBinaryStream(rs, "column"); 453 lobHandlerControl.setReturnValue(new ByteArrayInputStream (baos.toByteArray())); 454 lobCreator.setBlobAsBytes(ps, 1, baos.toByteArray()); 455 lobCreatorControl.setMatcher(new ArgumentsMatcher() { 456 public boolean matches(Object [] o1, Object [] o2) { 457 return Arrays.equals((byte[]) o1[2], (byte[]) o2[2]); 458 } 459 public String toString(Object [] objects) { 460 return null; 461 } 462 }); 463 464 lobHandlerControl.replay(); 465 lobCreatorControl.replay(); 466 467 BlobSerializableType type = new BlobSerializableType(lobHandler, tm); 468 assertEquals(1, type.sqlTypes().length); 469 assertEquals(Types.BLOB, type.sqlTypes()[0]); 470 assertEquals(Serializable .class, type.returnedClass()); 471 assertTrue(type.isMutable()); 472 473 assertEquals("content", type.nullSafeGet(rs, new String [] {"column"}, null)); 474 tmControl.replay(); 475 type.nullSafeSet(ps, "content", 1); 476 Synchronization synch = transaction.getSynchronization(); 477 assertNotNull(synch); 478 synch.afterCompletion(Status.STATUS_ROLLEDBACK); 479 tmControl.verify(); 480 } 481 482 public void testHbm2JavaStyleInitialization() throws Exception { 483 rsControl.reset(); 484 psControl.reset(); 485 lobHandlerControl.reset(); 486 lobCreatorControl.reset(); 487 488 ClobStringType cst = null; 489 BlobByteArrayType bbat = null; 490 BlobSerializableType bst = null; 491 try { 492 cst = new ClobStringType(); 493 bbat = new BlobByteArrayType(); 494 bst = new BlobSerializableType(); 495 } 496 catch (Exception ex) { 497 fail("Should not have thrown exception on initialization"); 498 } 499 500 try { 501 cst.nullSafeGet(rs, new String [] {"column"}, null); 502 fail("Should have thrown IllegalStateException"); 503 } 504 catch (IllegalStateException ex) { 505 } 507 try { 508 bbat.nullSafeGet(rs, new String [] {"column"}, null); 509 fail("Should have thrown IllegalStateException"); 510 } 511 catch (IllegalStateException ex) { 512 } 514 try { 515 bst.nullSafeGet(rs, new String [] {"column"}, null); 516 fail("Should have thrown IllegalStateException"); 517 } 518 catch (IllegalStateException ex) { 519 } 521 } 522 523 protected void tearDown() { 524 try { 525 rsControl.verify(); 526 psControl.verify(); 527 lobHandlerControl.verify(); 528 lobCreatorControl.verify(); 529 } 530 catch (IllegalStateException ex) { 531 } 533 assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty()); 534 assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); 535 } 536 537 } 538 | Popular Tags |