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