1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.springframework.orm.hibernate4;
18
19 import java.lang.reflect.Proxy;
20 import java.sql.SQLException;
21 import java.util.ArrayList;
22 import java.util.Collections;
23 import java.util.Iterator;
24 import java.util.List;
25
26 import org.hibernate.Criteria;
27 import org.hibernate.Filter;
28 import org.hibernate.FlushMode;
29 import org.hibernate.HibernateException;
30 import org.hibernate.JDBCException;
31 import org.hibernate.NonUniqueResultException;
32 import org.hibernate.ObjectDeletedException;
33 import org.hibernate.ObjectNotFoundException;
34 import org.hibernate.PersistentObjectException;
35 import org.hibernate.PropertyValueException;
36 import org.hibernate.Query;
37 import org.hibernate.QueryException;
38 import org.hibernate.ReplicationMode;
39 import org.hibernate.Session;
40 import org.hibernate.SessionFactory;
41 import org.hibernate.StaleObjectStateException;
42 import org.hibernate.StaleStateException;
43 import org.hibernate.TransientObjectException;
44 import org.hibernate.UnresolvableObjectException;
45 import org.hibernate.WrongClassException;
46 import org.hibernate.exception.ConstraintViolationException;
47 import org.hibernate.exception.DataException;
48 import org.hibernate.exception.JDBCConnectionException;
49 import org.hibernate.exception.LockAcquisitionException;
50 import org.hibernate.exception.SQLGrammarException;
51 import org.junit.After;
52 import org.junit.Before;
53 import org.junit.Test;
54 import org.mockito.InOrder;
55
56 import org.springframework.dao.CannotAcquireLockException;
57 import org.springframework.dao.DataAccessResourceFailureException;
58 import org.springframework.dao.DataIntegrityViolationException;
59 import org.springframework.dao.IncorrectResultSizeDataAccessException;
60 import org.springframework.dao.InvalidDataAccessApiUsageException;
61 import org.springframework.dao.InvalidDataAccessResourceUsageException;
62 import org.springframework.tests.sample.beans.TestBean;
63 import org.springframework.transaction.support.TransactionSynchronizationManager;
64
65 import static org.junit.Assert.*;
66 import static org.mockito.BDDMockito.*;
67
68
69
70
71
72 @SuppressWarnings({ "rawtypes", "unchecked" })
73 public class HibernateTemplateTests {
74
75 private SessionFactory sessionFactory;
76 private Session session;
77 private HibernateTemplate hibernateTemplate;
78
79 @Before
80 public void setUp() {
81 this.sessionFactory = mock(SessionFactory.class);
82 this.session = mock(Session.class);
83 this.hibernateTemplate = new HibernateTemplate(sessionFactory);
84 given(sessionFactory.getCurrentSession()).willReturn(session);
85 }
86
87 @After
88 public void tearDown() {
89 assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
90 assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
91 }
92
93 @Test
94 public void testExecuteWithNewSession() {
95 given(sessionFactory.getCurrentSession()).willThrow(new HibernateException("no current session"));
96 given(sessionFactory.openSession()).willReturn(session);
97
98 final List l = new ArrayList();
99 l.add("test");
100 List result = hibernateTemplate.execute(new HibernateCallback<List>() {
101 @Override
102 public List doInHibernate(Session session) {
103 return l;
104 }
105 });
106 assertTrue("Correct result list", result == l);
107 verify(session).close();
108 }
109
110 @Test
111 public void testExecuteWithNewSessionAndFilter() {
112 given(sessionFactory.getCurrentSession()).willThrow(new HibernateException("no current session"));
113 given(sessionFactory.openSession()).willReturn(session);
114 hibernateTemplate.setFilterNames("myFilter");
115
116 final List l = new ArrayList();
117 l.add("test");
118 List result = hibernateTemplate.execute(new HibernateCallback<List>() {
119 @Override
120 public List doInHibernate(Session session) {
121 return l;
122 }
123 });
124 assertTrue("Correct result list", result == l);
125 verify(session).enableFilter("myFilter");
126 verify(session).close();
127 }
128
129 @Test
130 public void testExecuteWithNewSessionAndFilters() {
131 given(sessionFactory.getCurrentSession()).willThrow(new HibernateException("no current session"));
132 given(sessionFactory.openSession()).willReturn(session);
133 hibernateTemplate.setFilterNames("myFilter", "yourFilter");
134
135 final List l = new ArrayList();
136 l.add("test");
137 List result = hibernateTemplate.execute(new HibernateCallback<List>() {
138 @Override
139 public List doInHibernate(Session session) {
140 return l;
141 }
142 });
143 assertTrue("Correct result list", result == l);
144 InOrder ordered = inOrder(session);
145 ordered.verify(session).enableFilter("myFilter");
146 ordered.verify(session).enableFilter("yourFilter");
147 ordered.verify(session).close();
148 }
149
150 @Test
151 public void testExecuteWithThreadBound() {
152 final List l = new ArrayList();
153 l.add("test");
154 List result = hibernateTemplate.execute(new HibernateCallback<List>() {
155 @Override
156 public List doInHibernate(Session session) {
157 return l;
158 }
159 });
160 assertTrue("Correct result list", result == l);
161 }
162
163 @Test
164 public void testExecuteWithThreadBoundAndFilter() {
165 hibernateTemplate.setFilterNames("myFilter");
166
167 final List l = new ArrayList();
168 l.add("test");
169 List result = hibernateTemplate.execute(new HibernateCallback<List>() {
170 @Override
171 public List doInHibernate(Session session) {
172 return l;
173 }
174 });
175 assertTrue("Correct result list", result == l);
176
177 InOrder ordered = inOrder(session);
178 ordered.verify(session).enableFilter("myFilter");
179 ordered.verify(session).disableFilter("myFilter");
180 }
181
182 @Test
183 public void testExecuteWithThreadBoundAndFilters() {
184 hibernateTemplate.setFilterNames("myFilter", "yourFilter");
185
186 final List l = new ArrayList();
187 l.add("test");
188 List result = hibernateTemplate.execute(new HibernateCallback<List>() {
189 @Override
190 public List doInHibernate(Session session) {
191 return l;
192 }
193 });
194 assertTrue("Correct result list", result == l);
195
196 InOrder ordered = inOrder(session);
197 ordered.verify(session).enableFilter("myFilter");
198 ordered.verify(session).enableFilter("yourFilter");
199 ordered.verify(session).disableFilter("myFilter");
200 ordered.verify(session).disableFilter("yourFilter");
201 }
202
203 @Test
204 public void testExecuteWithThreadBoundAndParameterizedFilter() {
205 Filter filter = mock(Filter.class);
206 given(session.enableFilter("myFilter")).willReturn(filter);
207 hibernateTemplate.setFilterNames("myFilter");
208
209 final List l = new ArrayList();
210 l.add("test");
211 Filter f = hibernateTemplate.enableFilter("myFilter");
212 assertTrue("Correct filter", f == filter);
213
214 InOrder ordered = inOrder(session);
215 ordered.verify(session).getEnabledFilter("myFilter");
216 ordered.verify(session).enableFilter("myFilter");
217 }
218
219 @Test
220 public void testExecuteWithThreadBoundAndParameterizedExistingFilter() {
221 Filter filter = mock(Filter.class);
222 given(session.enableFilter("myFilter")).willReturn(filter);
223 hibernateTemplate.setFilterNames("myFilter");
224
225 final List l = new ArrayList();
226 l.add("test");
227 Filter f = hibernateTemplate.enableFilter("myFilter");
228 assertTrue("Correct filter", f == filter);
229
230 verify(session).getEnabledFilter("myFilter");
231 }
232
233 @Test
234 public void testExecuteWithCacheQueries() {
235 Query query1 = mock(Query.class);
236 Query query2 = mock(Query.class);
237 Criteria criteria = mock(Criteria.class);
238 given(session.createQuery("some query")).willReturn(query1);
239 given(query1.setCacheable(true)).willReturn(query1);
240 given(session.getNamedQuery("some query name")).willReturn(query2);
241 given(query2.setCacheable(true)).willReturn(query2);
242 given(session.createCriteria(TestBean.class)).willReturn(criteria);
243 given(criteria.setCacheable(true)).willReturn(criteria);
244
245 hibernateTemplate.setCacheQueries(true);
246 hibernateTemplate.execute(new HibernateCallback<Object>() {
247 @Override
248 public Object doInHibernate(Session sess) {
249 assertNotSame(session, sess);
250 assertTrue(Proxy.isProxyClass(sess.getClass()));
251 sess.createQuery("some query");
252 sess.getNamedQuery("some query name");
253 sess.createCriteria(TestBean.class);
254
255 sess.close();
256 return null;
257 }
258 });
259 }
260
261 @Test
262 public void testExecuteWithCacheQueriesAndCacheRegion() {
263 Query query1 = mock(Query.class);
264 Query query2 = mock(Query.class);
265 Criteria criteria = mock(Criteria.class);
266 given(session.createQuery("some query")).willReturn(query1);
267 given(query1.setCacheable(true)).willReturn(query1);
268 given(query1.setCacheRegion("myRegion")).willReturn(query1);
269 given(session.getNamedQuery("some query name")).willReturn(query2);
270 given(query2.setCacheable(true)).willReturn(query2);
271 given(query2.setCacheRegion("myRegion")).willReturn(query2);
272 given(session.createCriteria(TestBean.class)).willReturn(criteria);
273 given(criteria.setCacheable(true)).willReturn(criteria);
274 given(criteria.setCacheRegion("myRegion")).willReturn(criteria);
275
276 hibernateTemplate.setCacheQueries(true);
277 hibernateTemplate.setQueryCacheRegion("myRegion");
278 hibernateTemplate.execute(new HibernateCallback<Object>() {
279 @Override
280 public Object doInHibernate(Session sess) {
281 assertNotSame(session, sess);
282 assertTrue(Proxy.isProxyClass(sess.getClass()));
283 sess.createQuery("some query");
284 sess.getNamedQuery("some query name");
285 sess.createCriteria(TestBean.class);
286
287 sess.close();
288 return null;
289 }
290 });
291 }
292
293 @Test
294 public void testExecuteWithCacheQueriesAndCacheRegionAndNativeSession() {
295 Query query1 = mock(Query.class);
296 Query query2 = mock(Query.class);
297 Criteria criteria = mock(Criteria.class);
298
299 given(session.createQuery("some query")).willReturn(query1);
300 given(session.getNamedQuery("some query name")).willReturn(query2);
301 given(session.createCriteria(TestBean.class)).willReturn(criteria);
302
303 hibernateTemplate.setExposeNativeSession(true);
304 hibernateTemplate.setCacheQueries(true);
305 hibernateTemplate.setQueryCacheRegion("myRegion");
306 hibernateTemplate.execute(new HibernateCallback<Object>() {
307 @Override
308 public Object doInHibernate(Session sess) {
309 assertSame(session, sess);
310 sess.createQuery("some query");
311 sess.getNamedQuery("some query name");
312 sess.createCriteria(TestBean.class);
313 return null;
314 }
315 });
316 }
317
318 @Test
319 public void testExecuteWithFetchSizeAndMaxResults() {
320 Query query1 = mock(Query.class);
321 Query query2 = mock(Query.class);
322 Criteria criteria = mock(Criteria.class);
323
324 given(session.createQuery("some query")).willReturn(query1);
325 given(query1.setFetchSize(10)).willReturn(query1);
326 given(query1.setMaxResults(20)).willReturn(query1);
327 given(session.getNamedQuery("some query name")).willReturn(query2);
328 given(query2.setFetchSize(10)).willReturn(query2);
329 given(query2.setMaxResults(20)).willReturn(query2);
330 given(session.createCriteria(TestBean.class)).willReturn(criteria);
331 given(criteria.setFetchSize(10)).willReturn(criteria);
332 given(criteria.setMaxResults(20)).willReturn(criteria);
333
334 hibernateTemplate.setFetchSize(10);
335 hibernateTemplate.setMaxResults(20);
336 hibernateTemplate.execute(new HibernateCallback<Object>() {
337 @Override
338 public Object doInHibernate(Session sess) {
339 sess.createQuery("some query");
340 sess.getNamedQuery("some query name");
341 sess.createCriteria(TestBean.class);
342 return null;
343 }
344 });
345 }
346
347 @Test
348 public void testGet() {
349 TestBean tb = new TestBean();
350 given(session.get(TestBean.class, "")).willReturn(tb);
351 Object result = hibernateTemplate.get(TestBean.class, "");
352 assertTrue("Correct result", result == tb);
353 }
354
355 @Test
356 public void testGetWithEntityName() {
357 TestBean tb = new TestBean();
358 given(session.get("myEntity", "")).willReturn(tb);
359 Object result = hibernateTemplate.get("myEntity", "");
360 assertTrue("Correct result", result == tb);
361 }
362
363 @Test
364 public void testLoad() {
365 TestBean tb = new TestBean();
366 given(session.load(TestBean.class, "")).willReturn(tb);
367 Object result = hibernateTemplate.load(TestBean.class, "");
368 assertTrue("Correct result", result == tb);
369 }
370
371 @Test
372 public void testLoadWithNotFound() {
373 ObjectNotFoundException onfex = new ObjectNotFoundException("id", TestBean.class.getName());
374 given(session.load(TestBean.class, "id")).willThrow(onfex);
375 try {
376 hibernateTemplate.load(TestBean.class, "id");
377 fail("Should have thrown HibernateObjectRetrievalFailureException");
378 }
379 catch (HibernateObjectRetrievalFailureException ex) {
380
381 assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
382 assertEquals("id", ex.getIdentifier());
383 assertEquals(onfex, ex.getCause());
384 }
385 }
386
387 @Test
388 public void testLoadWithEntityName() {
389 TestBean tb = new TestBean();
390 given(session.load("myEntity", "")).willReturn(tb);
391 Object result = hibernateTemplate.load("myEntity", "");
392 assertTrue("Correct result", result == tb);
393 }
394
395 @Test
396 public void testLoadWithObject() {
397 TestBean tb = new TestBean();
398 hibernateTemplate.load(tb, "");
399 verify(session).load(tb, "");
400 }
401
402 @Test
403 public void testLoadAll() {
404 Criteria criteria = mock(Criteria.class);
405 List list = new ArrayList();
406 given(session.createCriteria(TestBean.class)).willReturn(criteria);
407 given(criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)).willReturn(criteria);
408 given(criteria.list()).willReturn(list);
409 List result = hibernateTemplate.loadAll(TestBean.class);
410 assertTrue("Correct result", result == list);
411 }
412
413 @Test
414 public void testLoadAllWithCacheable() {
415 Criteria criteria = mock(Criteria.class);
416 List list = new ArrayList();
417 given(session.createCriteria(TestBean.class)).willReturn(criteria);
418 given(criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)).willReturn(criteria);
419 given(criteria.setCacheable(true)).willReturn(criteria);
420 given(criteria.list()).willReturn(list);
421
422 hibernateTemplate.setCacheQueries(true);
423 List result = hibernateTemplate.loadAll(TestBean.class);
424 assertTrue("Correct result", result == list);
425 verify(criteria).setCacheable(true);
426 }
427
428 @Test
429 public void testLoadAllWithCacheableAndCacheRegion() {
430 Criteria criteria = mock(Criteria.class);
431 List list = new ArrayList();
432 given(session.createCriteria(TestBean.class)).willReturn(criteria);
433 given(criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)).willReturn(criteria);
434 given(criteria.setCacheable(true)).willReturn(criteria);
435 given(criteria.setCacheRegion("myCacheRegion")).willReturn(criteria);
436 given(criteria.list()).willReturn(list);
437
438 hibernateTemplate.setCacheQueries(true);
439 hibernateTemplate.setQueryCacheRegion("myCacheRegion");
440 List result = hibernateTemplate.loadAll(TestBean.class);
441 assertTrue("Correct result", result == list);
442 verify(criteria).setCacheable(true);
443 verify(criteria).setCacheRegion("myCacheRegion");
444 }
445
446 @Test public void testRefresh() {
447 TestBean tb = new TestBean();
448 hibernateTemplate.refresh(tb);
449 verify(session).refresh(tb);
450 }
451
452 @Test public void testContains() {
453 TestBean tb = new TestBean();
454 given(session.contains(tb)).willReturn(true);
455 assertTrue(hibernateTemplate.contains(tb));
456 }
457
458 @Test
459 public void testEvict() {
460 TestBean tb = new TestBean();
461 hibernateTemplate.evict(tb);
462 verify(session).evict(tb);
463 }
464
465 @Test
466 public void testSave() {
467 TestBean tb = new TestBean();
468 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
469 given(session.save(tb)).willReturn(0);
470 assertEquals("Correct return value", hibernateTemplate.save(tb), 0);
471 }
472
473 @Test
474 public void testSaveWithEntityName() {
475 TestBean tb = new TestBean();
476 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
477 given(session.save("myEntity", tb)).willReturn(0);
478 assertEquals("Correct return value", hibernateTemplate.save("myEntity", tb), 0);
479 }
480
481 @Test
482 public void testUpdate() {
483 TestBean tb = new TestBean();
484 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
485 hibernateTemplate.update(tb);
486 verify(session).update(tb);
487 }
488
489 @Test
490 public void testUpdateWithEntityName() {
491 TestBean tb = new TestBean();
492 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
493 hibernateTemplate.update("myEntity", tb);
494 verify(session).update("myEntity", tb);
495 }
496
497 @Test
498 public void testSaveOrUpdate() {
499 TestBean tb = new TestBean();
500 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
501 hibernateTemplate.saveOrUpdate(tb);
502 verify(session).saveOrUpdate(tb);
503 }
504
505 @Test
506 public void testSaveOrUpdateWithFlushModeNever() {
507 TestBean tb = new TestBean();
508 given(session.getFlushMode()).willReturn(FlushMode.MANUAL);
509 try {
510 hibernateTemplate.saveOrUpdate(tb);
511 fail("Should have thrown InvalidDataAccessApiUsageException");
512 }
513 catch (InvalidDataAccessApiUsageException ex) {
514
515 }
516 }
517
518 @Test
519 public void testSaveOrUpdateWithEntityName() {
520 TestBean tb = new TestBean();
521
522 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
523 hibernateTemplate.saveOrUpdate("myEntity", tb);
524 verify(session).saveOrUpdate("myEntity", tb);
525 }
526
527 @Test
528 public void testReplicate() {
529 TestBean tb = new TestBean();
530 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
531 hibernateTemplate.replicate(tb, ReplicationMode.LATEST_VERSION);
532 verify(session).replicate(tb, ReplicationMode.LATEST_VERSION);
533 }
534
535 @Test
536 public void testReplicateWithEntityName() {
537 TestBean tb = new TestBean();
538 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
539 hibernateTemplate.replicate("myEntity", tb, ReplicationMode.LATEST_VERSION);
540 verify(session).replicate("myEntity", tb, ReplicationMode.LATEST_VERSION);
541 }
542
543 @Test
544 public void testPersist() {
545 TestBean tb = new TestBean();
546 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
547 hibernateTemplate.persist(tb);
548 verify(session).persist(tb);
549 }
550
551 @Test
552 public void testPersistWithEntityName() {
553 TestBean tb = new TestBean();
554 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
555 hibernateTemplate.persist("myEntity", tb);
556 verify(session).persist("myEntity", tb);
557 }
558
559 @Test
560 public void testMerge() {
561 TestBean tb = new TestBean();
562 TestBean tbMerged = new TestBean();
563 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
564 given(session.merge(tb)).willReturn(tbMerged);
565 assertSame(tbMerged, hibernateTemplate.merge(tb));
566 }
567
568 @Test
569 public void testMergeWithEntityName() {
570 TestBean tb = new TestBean();
571 TestBean tbMerged = new TestBean();
572 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
573 given(session.merge("myEntity", tb)).willReturn(tbMerged);
574 assertSame(tbMerged, hibernateTemplate.merge("myEntity", tb));
575 }
576
577 @Test
578 public void testDelete() {
579 TestBean tb = new TestBean();
580 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
581 hibernateTemplate.delete(tb);
582 verify(session).delete(tb);
583 }
584
585 @Test
586 public void testDeleteWithEntityName() {
587 TestBean tb = new TestBean();
588 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
589 hibernateTemplate.delete("myEntity", tb);
590 verify(session).delete("myEntity", tb);
591 }
592
593 @Test
594 public void testDeleteAll() {
595 TestBean tb1 = new TestBean();
596 TestBean tb2 = new TestBean();
597 given(session.getFlushMode()).willReturn(FlushMode.AUTO);
598 List tbs = new ArrayList();
599 tbs.add(tb1);
600 tbs.add(tb2);
601 hibernateTemplate.deleteAll(tbs);
602 verify(session).delete(same(tb1));
603 verify(session).delete(same(tb2));
604 }
605
606 @Test
607 public void testFlush() {
608 hibernateTemplate.flush();
609 verify(session).flush();
610 }
611
612 @Test
613 public void testClear() {
614 hibernateTemplate.clear();
615 verify(session).clear();
616 }
617
618 @Test
619 public void testFind() {
620 Query query = mock(Query.class);
621 List list = new ArrayList();
622 given(session.createQuery("some query string")).willReturn(query);
623 given(query.list()).willReturn(list);
624 List result = hibernateTemplate.find("some query string");
625 assertTrue("Correct list", result == list);
626 }
627
628 @Test
629 public void testFindWithParameter() {
630 Query query = mock(Query.class);
631 List list = new ArrayList();
632 given(session.createQuery("some query string")).willReturn(query);
633 given(query.setParameter(0, "myvalue")).willReturn(query);
634 given(query.list()).willReturn(list);
635 List result = hibernateTemplate.find("some query string", "myvalue");
636 assertTrue("Correct list", result == list);
637 verify(query).setParameter(0, "myvalue");
638 }
639
640 @Test
641 public void testFindWithParameters() {
642 Query query = mock(Query.class);
643 List list = new ArrayList();
644 given(session.createQuery("some query string")).willReturn(query);
645 given(query.setParameter(0, "myvalue1")).willReturn(query);
646 given(query.setParameter(1, 2)).willReturn(query);
647 given(query.list()).willReturn(list);
648 List result = hibernateTemplate.find("some query string", "myvalue1", 2);
649 assertTrue("Correct list", result == list);
650 verify(query).setParameter(0, "myvalue1");
651 verify(query).setParameter(1, 2);
652 }
653
654 @Test
655 public void testFindWithNamedParameter() {
656 Query query = mock(Query.class);
657 List list = new ArrayList();
658 given(session.createQuery("some query string")).willReturn(query);
659 given(query.setParameter("myparam", "myvalue")).willReturn(query);
660 given(query.list()).willReturn(list);
661 List result = hibernateTemplate.findByNamedParam("some query string", "myparam", "myvalue");
662 assertTrue("Correct list", result == list);
663 verify(query).setParameter("myparam", "myvalue");
664 }
665
666 @Test
667 public void testFindWithNamedParameters() {
668 Query query = mock(Query.class);
669 List list = new ArrayList();
670 given(session.createQuery("some query string")).willReturn(query);
671 given(query.setParameter("myparam1", "myvalue1")).willReturn(query);
672 given(query.setParameter("myparam2", 2)).willReturn(query);
673 given(query.list()).willReturn(list);
674 List result = hibernateTemplate.findByNamedParam("some query string",
675 new String[]{"myparam1", "myparam2"},
676 new Object[]{"myvalue1", 2});
677 assertTrue("Correct list", result == list);
678 verify(query).setParameter("myparam1", "myvalue1");
679 verify(query).setParameter("myparam2", 2);
680 }
681
682 @Test
683 public void testFindByValueBean() {
684 Query query = mock(Query.class);
685 TestBean tb = new TestBean();
686 List list = new ArrayList();
687 given(session.createQuery("some query string")).willReturn(query);
688 given(query.setProperties(tb)).willReturn(query);
689 given(query.list()).willReturn(list);
690 List result = hibernateTemplate.findByValueBean("some query string", tb);
691 assertTrue("Correct list", result == list);
692 verify(query).setProperties(tb);
693 }
694
695 @Test
696 public void testFindByNamedQuery() {
697 Query query = mock(Query.class);
698 List list = new ArrayList();
699 given(session.getNamedQuery("some query name")).willReturn(query);
700 given(query.list()).willReturn(list);
701 List result = hibernateTemplate.findByNamedQuery("some query name");
702 assertTrue("Correct list", result == list);
703 }
704
705 @Test
706 public void testFindByNamedQueryWithParameter() {
707 Query query = mock(Query.class);
708 List list = new ArrayList();
709 given(session.getNamedQuery("some query name")).willReturn(query);
710 given(query.setParameter(0, "myvalue")).willReturn(query);
711 given(query.list()).willReturn(list);
712 List result = hibernateTemplate.findByNamedQuery("some query name", "myvalue");
713 assertTrue("Correct list", result == list);
714 verify(query).setParameter(0, "myvalue");
715 }
716
717 @Test
718 public void testFindByNamedQueryWithParameters() {
719 Query query = mock(Query.class);
720 List list = new ArrayList();
721 given(session.getNamedQuery("some query name")).willReturn(query);
722 given(query.setParameter(0, "myvalue1")).willReturn(query);
723 given(query.setParameter(1, 2)).willReturn(query);
724 given(query.list()).willReturn(list);
725 List result = hibernateTemplate.findByNamedQuery("some query name", new Object[] {"myvalue1", 2});
726 assertTrue("Correct list", result == list);
727 verify(query).setParameter(0, "myvalue1");
728 verify(query).setParameter(1, 2);
729 }
730
731 @Test
732 public void testFindByNamedQueryWithNamedParameter() {
733 Query query = mock(Query.class);
734 List list = new ArrayList();
735 given(session.getNamedQuery("some query name")).willReturn(query);
736 given(query.setParameter("myparam", "myvalue")).willReturn(query);
737 given(query.list()).willReturn(list);
738 List result = hibernateTemplate.findByNamedQueryAndNamedParam("some query name", "myparam", "myvalue");
739 assertTrue("Correct list", result == list);
740 verify(query).setParameter("myparam", "myvalue");
741 }
742
743 @Test
744 public void testFindByNamedQueryWithNamedParameters() {
745 Query query = mock(Query.class);
746 List list = new ArrayList();
747 given(session.getNamedQuery("some query name")).willReturn(query);
748 given(query.setParameter("myparam1", "myvalue1")).willReturn(query);
749 given(query.setParameter("myparam2", 2)).willReturn(query);
750 given(query.list()).willReturn(list);
751 List result = hibernateTemplate.findByNamedQueryAndNamedParam("some query name",
752 new String[]{"myparam1", "myparam2"},
753 new Object[]{"myvalue1", 2});
754 assertTrue("Correct list", result == list);
755 verify(query).setParameter("myparam1", "myvalue1");
756 verify(query).setParameter("myparam2", 2);
757 }
758
759 @Test
760 public void testFindByNamedQueryAndValueBean() {
761 Query query = mock(Query.class);
762 TestBean tb = new TestBean();
763 List list = new ArrayList();
764 given(session.getNamedQuery("some query name")).willReturn(query);
765 given(query.setProperties(tb)).willReturn(query);
766 given(query.list()).willReturn(list);
767 List result = hibernateTemplate.findByNamedQueryAndValueBean("some query name", tb);
768 assertTrue("Correct list", result == list);
769 verify(query).setProperties(tb);
770 }
771
772 @Test
773 public void testFindWithCacheable() {
774 Query query = mock(Query.class);
775 List list = new ArrayList();
776 given(session.createQuery("some query string")).willReturn(query);
777 given(query.setCacheable(true)).willReturn(query);
778 given(query.list()).willReturn(list);
779 hibernateTemplate.setCacheQueries(true);
780 List result = hibernateTemplate.find("some query string");
781 assertTrue("Correct list", result == list);
782 verify(query).setCacheable(true);
783 }
784
785 @Test
786 public void testFindWithCacheableAndCacheRegion() {
787 Query query = mock(Query.class);
788 List list = new ArrayList();
789 given(session.createQuery("some query string")).willReturn(query);
790 given(query.setCacheable(true)).willReturn(query);
791 given(query.setCacheRegion("myCacheRegion")).willReturn(query);
792 given(query.list()).willReturn(list);
793 hibernateTemplate.setCacheQueries(true);
794 hibernateTemplate.setQueryCacheRegion("myCacheRegion");
795 List result = hibernateTemplate.find("some query string");
796 assertTrue("Correct list", result == list);
797 verify(query).setCacheable(true);
798 verify(query).setCacheRegion("myCacheRegion");
799 }
800
801 @Test
802 public void testFindByNamedQueryWithCacheable() {
803 Query query = mock(Query.class);
804 List list = new ArrayList();
805 given(session.getNamedQuery("some query name")).willReturn(query);
806 given(query.setCacheable(true)).willReturn(query);
807 given(query.list()).willReturn(list);
808 hibernateTemplate.setCacheQueries(true);
809 List result = hibernateTemplate.findByNamedQuery("some query name");
810 assertTrue("Correct list", result == list);
811 verify(query).setCacheable(true);
812 }
813
814 @Test
815 public void testFindByNamedQueryWithCacheableAndCacheRegion() {
816 Query query = mock(Query.class);
817 List list = new ArrayList();
818 given(session.getNamedQuery("some query name")).willReturn(query);
819 given(query.setCacheable(true)).willReturn(query);
820 given(query.setCacheRegion("myCacheRegion")).willReturn(query);
821 given(query.list()).willReturn(list);
822 hibernateTemplate.setCacheQueries(true);
823 hibernateTemplate.setQueryCacheRegion("myCacheRegion");
824 List result = hibernateTemplate.findByNamedQuery("some query name");
825 assertTrue("Correct list", result == list);
826 verify(query).setCacheable(true);
827 verify(query).setCacheRegion("myCacheRegion");
828 }
829
830 @Test
831 public void testIterate() {
832 Query query = mock(Query.class);
833 Iterator it = Collections.EMPTY_LIST.iterator();
834 given(session.createQuery("some query string")).willReturn(query);
835 given(query.iterate()).willReturn(it);
836 Iterator result = hibernateTemplate.iterate("some query string");
837 assertTrue("Correct list", result == it);
838 }
839
840 @Test
841 public void testIterateWithParameter() {
842 Query query = mock(Query.class);
843 Iterator it = Collections.EMPTY_LIST.iterator();
844 given(session.createQuery("some query string")).willReturn(query);
845 given(query.setParameter(0, "myvalue")).willReturn(query);
846 given(query.iterate()).willReturn(it);
847 Iterator result = hibernateTemplate.iterate("some query string", "myvalue");
848 assertTrue("Correct list", result == it);
849 verify(query).setParameter(0, "myvalue");
850 }
851
852 @Test
853 public void testIterateWithParameters() {
854 Query query = mock(Query.class);
855 Iterator it = Collections.EMPTY_LIST.iterator();
856 given(session.createQuery("some query string")).willReturn(query);
857 given(query.setParameter(0, "myvalue1")).willReturn(query);
858 given(query.setParameter(1, 2)).willReturn(query);
859 given(query.iterate()).willReturn(it);
860 Iterator result = hibernateTemplate.iterate("some query string", "myvalue1", 2);
861 assertTrue("Correct list", result == it);
862 verify(query).setParameter(0, "myvalue1");
863 verify(query).setParameter(1, 2);
864 }
865
866 @Test
867 public void testBulkUpdate() {
868 Query query = mock(Query.class);
869 given(session.createQuery("some query string")).willReturn(query);
870 given(query.executeUpdate()).willReturn(5);
871 int result = hibernateTemplate.bulkUpdate("some query string");
872 assertTrue("Correct list", result == 5);
873 }
874
875 @Test
876 public void testBulkUpdateWithParameter() {
877 Query query = mock(Query.class);
878 given(session.createQuery("some query string")).willReturn(query);
879 given(query.setParameter(0, "myvalue")).willReturn(query);
880 given(query.executeUpdate()).willReturn(5);
881 int result = hibernateTemplate.bulkUpdate("some query string", "myvalue");
882 assertTrue("Correct list", result == 5);
883 verify(query).setParameter(0, "myvalue");
884 }
885
886 @Test
887 public void testBulkUpdateWithParameters() {
888 Query query = mock(Query.class);
889 given(session.createQuery("some query string")).willReturn(query);
890 given(query.setParameter(0, "myvalue1")).willReturn(query);
891 given(query.setParameter(1, 2)).willReturn(query);
892 given(query.executeUpdate()).willReturn(5);
893 int result = hibernateTemplate.bulkUpdate("some query string", "myvalue1", 2);
894 assertTrue("Correct list", result == 5);
895 verify(query).setParameter(0, "myvalue1");
896 verify(query).setParameter(1, 2);
897 }
898
899 @Test
900 public void testExceptions() {
901 SQLException sqlEx = new SQLException("argh", "27");
902
903 final JDBCConnectionException jcex = new JDBCConnectionException("mymsg", sqlEx);
904 try {
905 hibernateTemplate.execute(new HibernateCallback<Object>() {
906 @Override
907 public Object doInHibernate(Session session) {
908 throw jcex;
909 }
910 });
911 fail("Should have thrown DataAccessResourceFailureException");
912 }
913 catch (DataAccessResourceFailureException ex) {
914
915 assertEquals(jcex, ex.getCause());
916 assertTrue(ex.getMessage().contains("mymsg"));
917 }
918
919 final SQLGrammarException sgex = new SQLGrammarException("mymsg", sqlEx);
920 try {
921 hibernateTemplate.execute(new HibernateCallback<Object>() {
922 @Override
923 public Object doInHibernate(Session session) {
924 throw sgex;
925 }
926 });
927 fail("Should have thrown InvalidDataAccessResourceUsageException");
928 }
929 catch (InvalidDataAccessResourceUsageException ex) {
930
931 assertEquals(sgex, ex.getCause());
932 assertTrue(ex.getMessage().contains("mymsg"));
933 }
934
935 final LockAcquisitionException laex = new LockAcquisitionException("mymsg", sqlEx);
936 try {
937 hibernateTemplate.execute(new HibernateCallback<Object>() {
938 @Override
939 public Object doInHibernate(Session session) {
940 throw laex;
941 }
942 });
943 fail("Should have thrown CannotAcquireLockException");
944 }
945 catch (CannotAcquireLockException ex) {
946
947 assertEquals(laex, ex.getCause());
948 assertTrue(ex.getMessage().contains("mymsg"));
949 }
950
951 final ConstraintViolationException cvex = new ConstraintViolationException("mymsg", sqlEx, "myconstraint");
952 try {
953 hibernateTemplate.execute(new HibernateCallback<Object>() {
954 @Override
955 public Object doInHibernate(Session session) {
956 throw cvex;
957 }
958 });
959 fail("Should have thrown DataIntegrityViolationException");
960 }
961 catch (DataIntegrityViolationException ex) {
962
963 assertEquals(cvex, ex.getCause());
964 assertTrue(ex.getMessage().contains("mymsg"));
965 }
966
967 final DataException dex = new DataException("mymsg", sqlEx);
968 try {
969 hibernateTemplate.execute(new HibernateCallback<Object>() {
970 @Override
971 public Object doInHibernate(Session session) {
972 throw dex;
973 }
974 });
975 fail("Should have thrown DataIntegrityViolationException");
976 }
977 catch (DataIntegrityViolationException ex) {
978
979 assertEquals(dex, ex.getCause());
980 assertTrue(ex.getMessage().contains("mymsg"));
981 }
982
983 final JDBCException jdex = new JDBCException("mymsg", sqlEx);
984 try {
985 hibernateTemplate.execute(new HibernateCallback<Object>() {
986 @Override
987 public Object doInHibernate(Session session) {
988 throw jdex;
989 }
990 });
991 fail("Should have thrown HibernateJdbcException");
992 }
993 catch (HibernateJdbcException ex) {
994
995 assertEquals(jdex, ex.getCause());
996 assertTrue(ex.getMessage().contains("mymsg"));
997 }
998
999 final PropertyValueException pvex = new PropertyValueException("mymsg", "myentity", "myproperty");
1000 try {
1001 hibernateTemplate.execute(new HibernateCallback<Object>() {
1002 @Override
1003 public Object doInHibernate(Session session) {
1004 throw pvex;
1005 }
1006 });
1007 fail("Should have thrown DataIntegrityViolationException");
1008 }
1009 catch (DataIntegrityViolationException ex) {
1010
1011 assertEquals(pvex, ex.getCause());
1012 assertTrue(ex.getMessage().contains("mymsg"));
1013 }
1014
1015 try {
1016 hibernateTemplate.execute(new HibernateCallback<Object>() {
1017 @Override
1018 public Object doInHibernate(Session session) {
1019 throw new PersistentObjectException("");
1020 }
1021 });
1022 fail("Should have thrown InvalidDataAccessApiUsageException");
1023 }
1024 catch (InvalidDataAccessApiUsageException ex) {
1025
1026 }
1027
1028 try {
1029 hibernateTemplate.execute(new HibernateCallback<Object>() {
1030 @Override
1031 public Object doInHibernate(Session session) {
1032 throw new TransientObjectException("");
1033 }
1034 });
1035 fail("Should have thrown InvalidDataAccessApiUsageException");
1036 }
1037 catch (InvalidDataAccessApiUsageException ex) {
1038
1039 }
1040
1041 final ObjectDeletedException odex = new ObjectDeletedException("msg", "id", TestBean.class.getName());
1042 try {
1043 hibernateTemplate.execute(new HibernateCallback<Object>() {
1044 @Override
1045 public Object doInHibernate(Session session) {
1046 throw odex;
1047 }
1048 });
1049 fail("Should have thrown InvalidDataAccessApiUsageException");
1050 }
1051 catch (InvalidDataAccessApiUsageException ex) {
1052
1053 assertEquals(odex, ex.getCause());
1054 }
1055
1056 final QueryException qex = new QueryException("msg", "query");
1057 try {
1058 hibernateTemplate.execute(new HibernateCallback<Object>() {
1059 @Override
1060 public Object doInHibernate(Session session) {
1061 throw qex;
1062 }
1063 });
1064 fail("Should have thrown InvalidDataAccessResourceUsageException");
1065 }
1066 catch (HibernateQueryException ex) {
1067
1068 assertEquals(qex, ex.getCause());
1069 assertEquals("query", ex.getQueryString());
1070 }
1071
1072 final UnresolvableObjectException uoex = new UnresolvableObjectException("id", TestBean.class.getName());
1073 try {
1074 hibernateTemplate.execute(new HibernateCallback<Object>() {
1075 @Override
1076 public Object doInHibernate(Session session) {
1077 throw uoex;
1078 }
1079 });
1080 fail("Should have thrown HibernateObjectRetrievalFailureException");
1081 }
1082 catch (HibernateObjectRetrievalFailureException ex) {
1083
1084 assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
1085 assertEquals("id", ex.getIdentifier());
1086 assertEquals(uoex, ex.getCause());
1087 }
1088
1089 final ObjectNotFoundException onfe = new ObjectNotFoundException("id", TestBean.class.getName());
1090 try {
1091 hibernateTemplate.execute(new HibernateCallback<Object>() {
1092 @Override
1093 public Object doInHibernate(Session session) {
1094 throw onfe;
1095 }
1096 });
1097 fail("Should have thrown HibernateObjectRetrievalFailureException");
1098 }
1099 catch (HibernateObjectRetrievalFailureException ex) {
1100
1101 assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
1102 assertEquals("id", ex.getIdentifier());
1103 assertEquals(onfe, ex.getCause());
1104 }
1105
1106 final WrongClassException wcex = new WrongClassException("msg", "id", TestBean.class.getName());
1107 try {
1108 hibernateTemplate.execute(new HibernateCallback<Object>() {
1109 @Override
1110 public Object doInHibernate(Session session) {
1111 throw wcex;
1112 }
1113 });
1114 fail("Should have thrown HibernateObjectRetrievalFailureException");
1115 }
1116 catch (HibernateObjectRetrievalFailureException ex) {
1117
1118 assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
1119 assertEquals("id", ex.getIdentifier());
1120 assertEquals(wcex, ex.getCause());
1121 }
1122
1123 final NonUniqueResultException nuex = new NonUniqueResultException(2);
1124 try {
1125 hibernateTemplate.execute(new HibernateCallback<Object>() {
1126 @Override
1127 public Object doInHibernate(Session session) {
1128 throw nuex;
1129 }
1130 });
1131 fail("Should have thrown IncorrectResultSizeDataAccessException");
1132 }
1133 catch (IncorrectResultSizeDataAccessException ex) {
1134
1135 assertEquals(1, ex.getExpectedSize());
1136 assertEquals(-1, ex.getActualSize());
1137 }
1138
1139 final StaleObjectStateException sosex = new StaleObjectStateException(TestBean.class.getName(), "id");
1140 try {
1141 hibernateTemplate.execute(new HibernateCallback<Object>() {
1142 @Override
1143 public Object doInHibernate(Session session) {
1144 throw sosex;
1145 }
1146 });
1147 fail("Should have thrown HibernateOptimisticLockingFailureException");
1148 }
1149 catch (HibernateOptimisticLockingFailureException ex) {
1150
1151 assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
1152 assertEquals("id", ex.getIdentifier());
1153 assertEquals(sosex, ex.getCause());
1154 }
1155
1156 final StaleStateException ssex = new StaleStateException("msg");
1157 try {
1158 hibernateTemplate.execute(new HibernateCallback<Object>() {
1159 @Override
1160 public Object doInHibernate(Session session) {
1161 throw ssex;
1162 }
1163 });
1164 fail("Should have thrown HibernateOptimisticLockingFailureException");
1165 }
1166 catch (HibernateOptimisticLockingFailureException ex) {
1167
1168 assertNull(ex.getPersistentClassName());
1169 assertNull(ex.getIdentifier());
1170 assertEquals(ssex, ex.getCause());
1171 }
1172
1173 final HibernateException hex = new HibernateException("msg");
1174 try {
1175 hibernateTemplate.execute(new HibernateCallback<Object>() {
1176 @Override
1177 public Object doInHibernate(Session session) {
1178 throw hex;
1179 }
1180 });
1181 fail("Should have thrown HibernateSystemException");
1182 }
1183 catch (HibernateSystemException ex) {
1184
1185 assertEquals(hex, ex.getCause());
1186 }
1187 }
1188
1189 }