|
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 |
Java API By Example, From Geeks To Geeks.