1 /* 2 * Copyright 2002-2008 the original author or authors. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package org.springframework.orm.hibernate3; 18 19 import java.lang.reflect.Proxy; 20 import java.sql.Connection; 21 import java.sql.SQLException; 22 import java.util.ArrayList; 23 import java.util.Collections; 24 import java.util.Iterator; 25 import java.util.List; 26 27 import junit.framework.TestCase; 28 import org.easymock.MockControl; 29 import org.hibernate.Criteria; 30 import org.hibernate.Filter; 31 import org.hibernate.FlushMode; 32 import org.hibernate.HibernateException; 33 import org.hibernate.Interceptor; 34 import org.hibernate.JDBCException; 35 import org.hibernate.LockMode; 36 import org.hibernate.NonUniqueResultException; 37 import org.hibernate.ObjectDeletedException; 38 import org.hibernate.ObjectNotFoundException; 39 import org.hibernate.PersistentObjectException; 40 import org.hibernate.PropertyValueException; 41 import org.hibernate.Query; 42 import org.hibernate.QueryException; 43 import org.hibernate.ReplicationMode; 44 import org.hibernate.SessionFactory; 45 import org.hibernate.StaleObjectStateException; 46 import org.hibernate.StaleStateException; 47 import org.hibernate.TransientObjectException; 48 import org.hibernate.UnresolvableObjectException; 49 import org.hibernate.WrongClassException; 50 import org.hibernate.classic.Session; 51 import org.hibernate.exception.ConstraintViolationException; 52 import org.hibernate.exception.DataException; 53 import org.hibernate.exception.GenericJDBCException; 54 import org.hibernate.exception.JDBCConnectionException; 55 import org.hibernate.exception.LockAcquisitionException; 56 import org.hibernate.exception.SQLGrammarException; 57 58 import org.springframework.beans.TestBean; 59 import org.springframework.dao.CannotAcquireLockException; 60 import org.springframework.dao.DataAccessResourceFailureException; 61 import org.springframework.dao.DataIntegrityViolationException; 62 import org.springframework.dao.IncorrectResultSizeDataAccessException; 63 import org.springframework.dao.InvalidDataAccessApiUsageException; 64 import org.springframework.dao.InvalidDataAccessResourceUsageException; 65 import org.springframework.transaction.support.TransactionSynchronizationManager; 66 67 /** 68 * @author Juergen Hoeller 69 * @since 05.03.2005 70 */ 71 public class HibernateTemplateTests extends TestCase { 72 73 private MockControl sfControl; 74 private SessionFactory sf; 75 private MockControl sessionControl; 76 private Session session; 77 setUp()78 protected void setUp() { 79 sfControl = MockControl.createControl(SessionFactory.class); 80 sf = (SessionFactory) sfControl.getMock(); 81 sessionControl = MockControl.createControl(Session.class); 82 session = (Session) sessionControl.getMock(); 83 } 84 testExecuteWithNewSession()85 public void testExecuteWithNewSession() throws HibernateException { 86 sf.openSession(); 87 sfControl.setReturnValue(session, 1); 88 session.getSessionFactory(); 89 sessionControl.setReturnValue(sf, 1); 90 session.flush(); 91 sessionControl.setVoidCallable(1); 92 session.close(); 93 sessionControl.setReturnValue(null, 1); 94 sfControl.replay(); 95 sessionControl.replay(); 96 97 HibernateTemplate ht = new HibernateTemplate(sf); 98 assertTrue("Correct allowCreate default", ht.isAllowCreate()); 99 assertTrue("Correct flushMode default", ht.getFlushMode() == HibernateTemplate.FLUSH_AUTO); 100 final List l = new ArrayList(); 101 l.add("test"); 102 List result = ht.executeFind(new HibernateCallback() { 103 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 104 return l; 105 } 106 }); 107 assertTrue("Correct result list", result == l); 108 } 109 testExecuteWithNewSessionAndFlushNever()110 public void testExecuteWithNewSessionAndFlushNever() throws HibernateException { 111 sf.openSession(); 112 sfControl.setReturnValue(session, 1); 113 session.getSessionFactory(); 114 sessionControl.setReturnValue(sf, 1); 115 session.setFlushMode(FlushMode.MANUAL); 116 sessionControl.setVoidCallable(1); 117 session.close(); 118 sessionControl.setReturnValue(null, 1); 119 sfControl.replay(); 120 sessionControl.replay(); 121 122 HibernateTemplate ht = new HibernateTemplate(sf); 123 ht.setFlushMode(HibernateTemplate.FLUSH_NEVER); 124 final List l = new ArrayList(); 125 l.add("test"); 126 List result = ht.executeFind(new HibernateCallback() { 127 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 128 return l; 129 } 130 }); 131 assertTrue("Correct result list", result == l); 132 } 133 testExecuteWithNewSessionAndFilter()134 public void testExecuteWithNewSessionAndFilter() throws HibernateException { 135 sf.openSession(); 136 sfControl.setReturnValue(session, 1); 137 session.getSessionFactory(); 138 sessionControl.setReturnValue(sf, 1); 139 session.enableFilter("myFilter"); 140 sessionControl.setReturnValue(null, 1); 141 session.flush(); 142 sessionControl.setVoidCallable(1); 143 session.close(); 144 sessionControl.setReturnValue(null, 1); 145 sfControl.replay(); 146 sessionControl.replay(); 147 148 HibernateTemplate ht = new HibernateTemplate(sf); 149 ht.setFilterName("myFilter"); 150 final List l = new ArrayList(); 151 l.add("test"); 152 List result = ht.executeFind(new HibernateCallback() { 153 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 154 return l; 155 } 156 }); 157 assertTrue("Correct result list", result == l); 158 } 159 testExecuteWithNewSessionAndFilters()160 public void testExecuteWithNewSessionAndFilters() throws HibernateException { 161 sf.openSession(); 162 sfControl.setReturnValue(session, 1); 163 session.getSessionFactory(); 164 sessionControl.setReturnValue(sf, 1); 165 session.enableFilter("myFilter"); 166 sessionControl.setReturnValue(null, 1); 167 session.enableFilter("yourFilter"); 168 sessionControl.setReturnValue(null, 1); 169 session.flush(); 170 sessionControl.setVoidCallable(1); 171 session.close(); 172 sessionControl.setReturnValue(null, 1); 173 sfControl.replay(); 174 sessionControl.replay(); 175 176 HibernateTemplate ht = new HibernateTemplate(sf); 177 ht.setFilterNames(new String[] {"myFilter", "yourFilter"}); 178 final List l = new ArrayList(); 179 l.add("test"); 180 List result = ht.executeFind(new HibernateCallback() { 181 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 182 return l; 183 } 184 }); 185 assertTrue("Correct result list", result == l); 186 } 187 testExecuteWithNotAllowCreate()188 public void testExecuteWithNotAllowCreate() { 189 sf.getCurrentSession(); 190 sfControl.setThrowable(new HibernateException("")); 191 sfControl.replay(); 192 193 HibernateTemplate ht = new HibernateTemplate(); 194 ht.setSessionFactory(sf); 195 ht.setAllowCreate(false); 196 try { 197 ht.execute(new HibernateCallback() { 198 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 199 return null; 200 } 201 }); 202 fail("Should have thrown DataAccessException"); 203 } 204 catch (DataAccessResourceFailureException ex) { 205 // expected 206 } 207 } 208 testExecuteWithNotAllowCreateAndThreadBound()209 public void testExecuteWithNotAllowCreateAndThreadBound() { 210 sf.getCurrentSession(); 211 sfControl.setReturnValue(session); 212 sfControl.replay(); 213 214 HibernateTemplate ht = new HibernateTemplate(sf); 215 ht.setAllowCreate(false); 216 217 final List l = new ArrayList(); 218 l.add("test"); 219 List result = ht.executeFind(new HibernateCallback() { 220 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 221 return l; 222 } 223 }); 224 assertTrue("Correct result list", result == l); 225 } 226 testExecuteWithThreadBoundAndFlushEager()227 public void testExecuteWithThreadBoundAndFlushEager() throws HibernateException { 228 session.getSessionFactory(); 229 sessionControl.setReturnValue(sf, 1); 230 session.isOpen(); 231 sessionControl.setReturnValue(true, 1); 232 session.getFlushMode(); 233 sessionControl.setReturnValue(FlushMode.AUTO); 234 session.flush(); 235 sessionControl.setVoidCallable(1); 236 sfControl.replay(); 237 sessionControl.replay(); 238 239 HibernateTemplate ht = new HibernateTemplate(sf); 240 ht.setFlushModeName("FLUSH_EAGER"); 241 242 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session)); 243 try { 244 final List l = new ArrayList(); 245 l.add("test"); 246 List result = ht.executeFind(new HibernateCallback() { 247 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 248 return l; 249 } 250 }); 251 assertTrue("Correct result list", result == l); 252 } 253 finally { 254 TransactionSynchronizationManager.unbindResource(sf); 255 } 256 } 257 testExecuteWithThreadBoundAndFilter()258 public void testExecuteWithThreadBoundAndFilter() { 259 session.getSessionFactory(); 260 sessionControl.setReturnValue(sf, 1); 261 session.isOpen(); 262 sessionControl.setReturnValue(true, 1); 263 session.enableFilter("myFilter"); 264 sessionControl.setReturnValue(null, 1); 265 session.disableFilter("myFilter"); 266 sessionControl.setVoidCallable(1); 267 sfControl.replay(); 268 sessionControl.replay(); 269 270 HibernateTemplate ht = new HibernateTemplate(sf); 271 ht.setFilterName("myFilter"); 272 273 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session)); 274 try { 275 final List l = new ArrayList(); 276 l.add("test"); 277 List result = ht.executeFind(new HibernateCallback() { 278 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 279 return l; 280 } 281 }); 282 assertTrue("Correct result list", result == l); 283 } 284 finally { 285 TransactionSynchronizationManager.unbindResource(sf); 286 } 287 } 288 testExecuteWithThreadBoundAndFilters()289 public void testExecuteWithThreadBoundAndFilters() { 290 session.getSessionFactory(); 291 sessionControl.setReturnValue(sf, 1); 292 session.isOpen(); 293 sessionControl.setReturnValue(true, 1); 294 session.enableFilter("myFilter"); 295 sessionControl.setReturnValue(null, 1); 296 session.enableFilter("yourFilter"); 297 sessionControl.setReturnValue(null, 1); 298 session.disableFilter("myFilter"); 299 sessionControl.setVoidCallable(1); 300 session.disableFilter("yourFilter"); 301 sessionControl.setVoidCallable(1); 302 sfControl.replay(); 303 sessionControl.replay(); 304 305 HibernateTemplate ht = new HibernateTemplate(sf); 306 ht.setFilterNames(new String[] {"myFilter", "yourFilter"}); 307 308 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session)); 309 try { 310 final List l = new ArrayList(); 311 l.add("test"); 312 List result = ht.executeFind(new HibernateCallback() { 313 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 314 return l; 315 } 316 }); 317 assertTrue("Correct result list", result == l); 318 } 319 finally { 320 TransactionSynchronizationManager.unbindResource(sf); 321 } 322 } 323 testExecuteWithThreadBoundAndParameterizedFilter()324 public void testExecuteWithThreadBoundAndParameterizedFilter() { 325 MockControl filterControl = MockControl.createControl(Filter.class); 326 Filter filter = (Filter) filterControl.getMock(); 327 328 session.getSessionFactory(); 329 sessionControl.setReturnValue(sf, 1); 330 session.isOpen(); 331 sessionControl.setReturnValue(true, 1); 332 session.getEnabledFilter("myFilter"); 333 sessionControl.setReturnValue(null, 1); 334 session.enableFilter("myFilter"); 335 sessionControl.setReturnValue(filter, 1); 336 sfControl.replay(); 337 sessionControl.replay(); 338 339 HibernateTemplate ht = new HibernateTemplate(sf); 340 ht.setAllowCreate(false); 341 ht.setFilterName("myFilter"); 342 343 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session)); 344 try { 345 final List l = new ArrayList(); 346 l.add("test"); 347 Filter f = ht.enableFilter("myFilter"); 348 assertTrue("Correct filter", f == filter); 349 } 350 finally { 351 TransactionSynchronizationManager.unbindResource(sf); 352 } 353 } 354 testExecuteWithThreadBoundAndParameterizedExistingFilter()355 public void testExecuteWithThreadBoundAndParameterizedExistingFilter() { 356 MockControl filterControl = MockControl.createControl(Filter.class); 357 Filter filter = (Filter) filterControl.getMock(); 358 359 session.getSessionFactory(); 360 sessionControl.setReturnValue(sf, 1); 361 session.isOpen(); 362 sessionControl.setReturnValue(true, 1); 363 session.getEnabledFilter("myFilter"); 364 sessionControl.setReturnValue(filter, 1); 365 sfControl.replay(); 366 sessionControl.replay(); 367 368 HibernateTemplate ht = new HibernateTemplate(sf); 369 ht.setAllowCreate(false); 370 ht.setFilterName("myFilter"); 371 372 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session)); 373 try { 374 final List l = new ArrayList(); 375 l.add("test"); 376 Filter f = ht.enableFilter("myFilter"); 377 assertTrue("Correct filter", f == filter); 378 } 379 finally { 380 TransactionSynchronizationManager.unbindResource(sf); 381 } 382 } 383 testExecuteWithThreadBoundAndNewSession()384 public void testExecuteWithThreadBoundAndNewSession() throws HibernateException { 385 MockControl conControl = MockControl.createControl(Connection.class); 386 Connection con = (Connection) conControl.getMock(); 387 MockControl session2Control = MockControl.createControl(Session.class); 388 Session session2 = (Session) session2Control.getMock(); 389 390 session2.connection(); 391 session2Control.setReturnValue(con, 1); 392 sf.openSession(con); 393 sfControl.setReturnValue(session, 1); 394 session.flush(); 395 sessionControl.setVoidCallable(1); 396 session.close(); 397 sessionControl.setReturnValue(null, 1); 398 sfControl.replay(); 399 sessionControl.replay(); 400 session2Control.replay(); 401 402 HibernateTemplate ht = new HibernateTemplate(sf); 403 ht.setAlwaysUseNewSession(true); 404 405 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session2)); 406 try { 407 final List l = new ArrayList(); 408 l.add("test"); 409 List result = ht.executeFind(new HibernateCallback() { 410 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 411 return l; 412 } 413 }); 414 assertTrue("Correct result list", result == l); 415 } 416 finally { 417 TransactionSynchronizationManager.unbindResource(sf); 418 } 419 } 420 testExecuteWithThreadBoundAndNewSessionAndEntityInterceptor()421 public void testExecuteWithThreadBoundAndNewSessionAndEntityInterceptor() throws HibernateException { 422 MockControl interceptorControl = MockControl.createControl(org.hibernate.Interceptor.class); 423 Interceptor entityInterceptor = (Interceptor) interceptorControl.getMock(); 424 425 MockControl conControl = MockControl.createControl(Connection.class); 426 Connection con = (Connection) conControl.getMock(); 427 MockControl session2Control = MockControl.createControl(Session.class); 428 Session session2 = (Session) session2Control.getMock(); 429 430 session2.connection(); 431 session2Control.setReturnValue(con, 1); 432 sf.openSession(con, entityInterceptor); 433 sfControl.setReturnValue(session, 1); 434 session.flush(); 435 sessionControl.setVoidCallable(1); 436 session.close(); 437 sessionControl.setReturnValue(null, 1); 438 sfControl.replay(); 439 sessionControl.replay(); 440 session2Control.replay(); 441 442 HibernateTemplate ht = new HibernateTemplate(sf); 443 ht.setAlwaysUseNewSession(true); 444 ht.setEntityInterceptor(entityInterceptor); 445 446 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session2)); 447 try { 448 final List l = new ArrayList(); 449 l.add("test"); 450 List result = ht.executeFind(new HibernateCallback() { 451 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 452 return l; 453 } 454 }); 455 assertTrue("Correct result list", result == l); 456 } 457 finally { 458 TransactionSynchronizationManager.unbindResource(sf); 459 } 460 } 461 testExecuteWithEntityInterceptor()462 public void testExecuteWithEntityInterceptor() throws HibernateException { 463 MockControl interceptorControl = MockControl.createControl(org.hibernate.Interceptor.class); 464 Interceptor entityInterceptor = (Interceptor) interceptorControl.getMock(); 465 466 sf.openSession(entityInterceptor); 467 sfControl.setReturnValue(session, 1); 468 session.getSessionFactory(); 469 sessionControl.setReturnValue(sf, 1); 470 session.flush(); 471 sessionControl.setVoidCallable(1); 472 session.close(); 473 sessionControl.setReturnValue(null, 1); 474 sfControl.replay(); 475 sessionControl.replay(); 476 477 HibernateTemplate ht = new HibernateTemplate(sf); 478 ht.setEntityInterceptor(entityInterceptor); 479 final List l = new ArrayList(); 480 l.add("test"); 481 List result = ht.executeFind(new HibernateCallback() { 482 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 483 return l; 484 } 485 }); 486 assertTrue("Correct result list", result == l); 487 } 488 testExecuteWithCacheQueries()489 public void testExecuteWithCacheQueries() throws HibernateException { 490 MockControl query1Control = MockControl.createControl(Query.class); 491 Query query1 = (Query) query1Control.getMock(); 492 MockControl query2Control = MockControl.createControl(Query.class); 493 Query query2 = (Query) query2Control.getMock(); 494 MockControl criteriaControl = MockControl.createControl(Criteria.class); 495 Criteria criteria = (Criteria) criteriaControl.getMock(); 496 497 sf.openSession(); 498 sfControl.setReturnValue(session, 1); 499 session.getSessionFactory(); 500 sessionControl.setReturnValue(sf, 1); 501 session.createQuery("some query"); 502 sessionControl.setReturnValue(query1); 503 query1.setCacheable(true); 504 query1Control.setReturnValue(query1, 1); 505 session.getNamedQuery("some query name"); 506 sessionControl.setReturnValue(query2); 507 query2.setCacheable(true); 508 query2Control.setReturnValue(query2, 1); 509 session.createCriteria(TestBean.class); 510 sessionControl.setReturnValue(criteria, 1); 511 criteria.setCacheable(true); 512 criteriaControl.setReturnValue(criteria, 1); 513 session.flush(); 514 sessionControl.setVoidCallable(1); 515 session.close(); 516 sessionControl.setReturnValue(null, 1); 517 sfControl.replay(); 518 sessionControl.replay(); 519 query1Control.replay(); 520 query2Control.replay(); 521 criteriaControl.replay(); 522 523 HibernateTemplate ht = new HibernateTemplate(sf); 524 ht.setCacheQueries(true); 525 ht.execute(new HibernateCallback() { 526 public Object doInHibernate(org.hibernate.Session sess) throws HibernateException { 527 assertNotSame(session, sess); 528 assertTrue(Proxy.isProxyClass(sess.getClass())); 529 sess.createQuery("some query"); 530 sess.getNamedQuery("some query name"); 531 sess.createCriteria(TestBean.class); 532 // should be ignored 533 sess.close(); 534 return null; 535 } 536 }); 537 538 query1Control.verify(); 539 query2Control.verify(); 540 criteriaControl.verify(); 541 } 542 testExecuteWithCacheQueriesAndCacheRegion()543 public void testExecuteWithCacheQueriesAndCacheRegion() throws HibernateException { 544 MockControl query1Control = MockControl.createControl(Query.class); 545 Query query1 = (Query) query1Control.getMock(); 546 MockControl query2Control = MockControl.createControl(Query.class); 547 Query query2 = (Query) query2Control.getMock(); 548 MockControl criteriaControl = MockControl.createControl(Criteria.class); 549 Criteria criteria = (Criteria) criteriaControl.getMock(); 550 551 sf.openSession(); 552 sfControl.setReturnValue(session, 1); 553 session.getSessionFactory(); 554 sessionControl.setReturnValue(sf, 1); 555 session.createQuery("some query"); 556 sessionControl.setReturnValue(query1); 557 query1.setCacheable(true); 558 query1Control.setReturnValue(query1, 1); 559 query1.setCacheRegion("myRegion"); 560 query1Control.setReturnValue(query1, 1); 561 session.getNamedQuery("some query name"); 562 sessionControl.setReturnValue(query2); 563 query2.setCacheable(true); 564 query2Control.setReturnValue(query2, 1); 565 query2.setCacheRegion("myRegion"); 566 query2Control.setReturnValue(query2, 1); 567 session.createCriteria(TestBean.class); 568 sessionControl.setReturnValue(criteria, 1); 569 criteria.setCacheable(true); 570 criteriaControl.setReturnValue(criteria, 1); 571 criteria.setCacheRegion("myRegion"); 572 criteriaControl.setReturnValue(criteria, 1); 573 session.flush(); 574 sessionControl.setVoidCallable(1); 575 session.close(); 576 sessionControl.setReturnValue(null, 1); 577 sfControl.replay(); 578 sessionControl.replay(); 579 query1Control.replay(); 580 query2Control.replay(); 581 criteriaControl.replay(); 582 583 HibernateTemplate ht = new HibernateTemplate(sf); 584 ht.setCacheQueries(true); 585 ht.setQueryCacheRegion("myRegion"); 586 ht.execute(new HibernateCallback() { 587 public Object doInHibernate(org.hibernate.Session sess) throws HibernateException { 588 assertNotSame(session, sess); 589 assertTrue(Proxy.isProxyClass(sess.getClass())); 590 sess.createQuery("some query"); 591 sess.getNamedQuery("some query name"); 592 sess.createCriteria(TestBean.class); 593 // should be ignored 594 sess.close(); 595 return null; 596 } 597 }); 598 599 query1Control.verify(); 600 query2Control.verify(); 601 criteriaControl.verify(); 602 } 603 testExecuteWithCacheQueriesAndCacheRegionAndNativeSession()604 public void testExecuteWithCacheQueriesAndCacheRegionAndNativeSession() throws HibernateException { 605 MockControl query1Control = MockControl.createControl(Query.class); 606 Query query1 = (Query) query1Control.getMock(); 607 MockControl query2Control = MockControl.createControl(Query.class); 608 Query query2 = (Query) query2Control.getMock(); 609 MockControl criteriaControl = MockControl.createControl(Criteria.class); 610 Criteria criteria = (Criteria) criteriaControl.getMock(); 611 612 sf.openSession(); 613 sfControl.setReturnValue(session, 1); 614 session.getSessionFactory(); 615 sessionControl.setReturnValue(sf, 1); 616 session.createQuery("some query"); 617 sessionControl.setReturnValue(query1); 618 session.getNamedQuery("some query name"); 619 sessionControl.setReturnValue(query2); 620 session.createCriteria(TestBean.class); 621 sessionControl.setReturnValue(criteria, 1); 622 session.flush(); 623 sessionControl.setVoidCallable(1); 624 session.close(); 625 sessionControl.setReturnValue(null, 1); 626 sfControl.replay(); 627 sessionControl.replay(); 628 query1Control.replay(); 629 query2Control.replay(); 630 criteriaControl.replay(); 631 632 HibernateTemplate ht = new HibernateTemplate(sf); 633 ht.setExposeNativeSession(true); 634 ht.setCacheQueries(true); 635 ht.setQueryCacheRegion("myRegion"); 636 ht.execute(new HibernateCallback() { 637 public Object doInHibernate(org.hibernate.Session sess) throws HibernateException { 638 assertSame(session, sess); 639 sess.createQuery("some query"); 640 sess.getNamedQuery("some query name"); 641 sess.createCriteria(TestBean.class); 642 return null; 643 } 644 }); 645 646 query1Control.verify(); 647 query2Control.verify(); 648 criteriaControl.verify(); 649 } 650 testExecuteWithFetchSizeAndMaxResults()651 public void testExecuteWithFetchSizeAndMaxResults() throws HibernateException { 652 MockControl query1Control = MockControl.createControl(Query.class); 653 Query query1 = (Query) query1Control.getMock(); 654 MockControl query2Control = MockControl.createControl(Query.class); 655 Query query2 = (Query) query2Control.getMock(); 656 MockControl criteriaControl = MockControl.createControl(Criteria.class); 657 Criteria criteria = (Criteria) criteriaControl.getMock(); 658 659 sf.openSession(); 660 sfControl.setReturnValue(session, 1); 661 session.getSessionFactory(); 662 sessionControl.setReturnValue(sf, 1); 663 session.createQuery("some query"); 664 sessionControl.setReturnValue(query1); 665 query1.setFetchSize(10); 666 query1Control.setReturnValue(query1, 1); 667 query1.setMaxResults(20); 668 query1Control.setReturnValue(query1, 1); 669 session.getNamedQuery("some query name"); 670 sessionControl.setReturnValue(query2); 671 query2.setFetchSize(10); 672 query2Control.setReturnValue(query2, 1); 673 query2.setMaxResults(20); 674 query2Control.setReturnValue(query2, 1); 675 session.createCriteria(TestBean.class); 676 sessionControl.setReturnValue(criteria, 1); 677 criteria.setFetchSize(10); 678 criteriaControl.setReturnValue(criteria, 1); 679 criteria.setMaxResults(20); 680 criteriaControl.setReturnValue(criteria, 1); 681 session.flush(); 682 sessionControl.setVoidCallable(1); 683 session.close(); 684 sessionControl.setReturnValue(null, 1); 685 sfControl.replay(); 686 sessionControl.replay(); 687 query1Control.replay(); 688 query2Control.replay(); 689 criteriaControl.replay(); 690 691 HibernateTemplate ht = new HibernateTemplate(sf); 692 ht.setFetchSize(10); 693 ht.setMaxResults(20); 694 ht.execute(new HibernateCallback() { 695 public Object doInHibernate(org.hibernate.Session sess) throws HibernateException { 696 sess.createQuery("some query"); 697 sess.getNamedQuery("some query name"); 698 sess.createCriteria(TestBean.class); 699 return null; 700 } 701 }); 702 703 query1Control.verify(); 704 query2Control.verify(); 705 criteriaControl.verify(); 706 } 707 testGet()708 public void testGet() throws HibernateException { 709 TestBean tb = new TestBean(); 710 sf.openSession(); 711 sfControl.setReturnValue(session, 1); 712 session.getSessionFactory(); 713 sessionControl.setReturnValue(sf, 1); 714 session.get(TestBean.class, ""); 715 sessionControl.setReturnValue(tb, 1); 716 session.flush(); 717 sessionControl.setVoidCallable(1); 718 session.close(); 719 sessionControl.setReturnValue(null, 1); 720 sfControl.replay(); 721 sessionControl.replay(); 722 723 HibernateTemplate ht = new HibernateTemplate(sf); 724 Object result = ht.get(TestBean.class, ""); 725 assertTrue("Correct result", result == tb); 726 } 727 testGetWithLockMode()728 public void testGetWithLockMode() throws HibernateException { 729 TestBean tb = new TestBean(); 730 sf.openSession(); 731 sfControl.setReturnValue(session, 1); 732 session.getSessionFactory(); 733 sessionControl.setReturnValue(sf, 1); 734 session.get(TestBean.class, "", LockMode.UPGRADE_NOWAIT); 735 sessionControl.setReturnValue(tb, 1); 736 session.flush(); 737 sessionControl.setVoidCallable(1); 738 session.close(); 739 sessionControl.setReturnValue(null, 1); 740 sfControl.replay(); 741 sessionControl.replay(); 742 743 HibernateTemplate ht = new HibernateTemplate(sf); 744 Object result = ht.get(TestBean.class, "", LockMode.UPGRADE_NOWAIT); 745 assertTrue("Correct result", result == tb); 746 } 747 testGetWithEntityName()748 public void testGetWithEntityName() throws HibernateException { 749 TestBean tb = new TestBean(); 750 sf.openSession(); 751 sfControl.setReturnValue(session, 1); 752 session.getSessionFactory(); 753 sessionControl.setReturnValue(sf, 1); 754 session.get("myEntity", ""); 755 sessionControl.setReturnValue(tb, 1); 756 session.flush(); 757 sessionControl.setVoidCallable(1); 758 session.close(); 759 sessionControl.setReturnValue(null, 1); 760 sfControl.replay(); 761 sessionControl.replay(); 762 763 HibernateTemplate ht = new HibernateTemplate(sf); 764 Object result = ht.get("myEntity", ""); 765 assertTrue("Correct result", result == tb); 766 } 767 testGetWithEntityNameAndLockMode()768 public void testGetWithEntityNameAndLockMode() throws HibernateException { 769 TestBean tb = new TestBean(); 770 sf.openSession(); 771 sfControl.setReturnValue(session, 1); 772 session.getSessionFactory(); 773 sessionControl.setReturnValue(sf, 1); 774 session.get("myEntity", "", LockMode.UPGRADE_NOWAIT); 775 sessionControl.setReturnValue(tb, 1); 776 session.flush(); 777 sessionControl.setVoidCallable(1); 778 session.close(); 779 sessionControl.setReturnValue(null, 1); 780 sfControl.replay(); 781 sessionControl.replay(); 782 783 HibernateTemplate ht = new HibernateTemplate(sf); 784 Object result = ht.get("myEntity", "", LockMode.UPGRADE_NOWAIT); 785 assertTrue("Correct result", result == tb); 786 } 787 testLoad()788 public void testLoad() throws HibernateException { 789 TestBean tb = new TestBean(); 790 791 sf.openSession(); 792 sfControl.setReturnValue(session, 1); 793 session.getSessionFactory(); 794 sessionControl.setReturnValue(sf, 1); 795 session.load(TestBean.class, ""); 796 sessionControl.setReturnValue(tb, 1); 797 session.flush(); 798 sessionControl.setVoidCallable(1); 799 session.close(); 800 sessionControl.setReturnValue(null, 1); 801 sfControl.replay(); 802 sessionControl.replay(); 803 804 HibernateTemplate ht = new HibernateTemplate(sf); 805 Object result = ht.load(TestBean.class, ""); 806 assertTrue("Correct result", result == tb); 807 } 808 testLoadWithNotFound()809 public void testLoadWithNotFound() throws HibernateException { 810 sf.openSession(); 811 sfControl.setReturnValue(session, 1); 812 session.getSessionFactory(); 813 sessionControl.setReturnValue(sf, 1); 814 session.load(TestBean.class, "id"); 815 ObjectNotFoundException onfex = new ObjectNotFoundException("id", TestBean.class.getName()); 816 sessionControl.setThrowable(onfex); 817 session.close(); 818 sessionControl.setReturnValue(null, 1); 819 sfControl.replay(); 820 sessionControl.replay(); 821 822 HibernateTemplate ht = new HibernateTemplate(sf); 823 try { 824 ht.load(TestBean.class, "id"); 825 fail("Should have thrown HibernateObjectRetrievalFailureException"); 826 } 827 catch (HibernateObjectRetrievalFailureException ex) { 828 // expected 829 assertEquals(TestBean.class.getName(), ex.getPersistentClassName()); 830 assertEquals("id", ex.getIdentifier()); 831 assertEquals(onfex, ex.getCause()); 832 } 833 } 834 testLoadWithLockMode()835 public void testLoadWithLockMode() throws HibernateException { 836 TestBean tb = new TestBean(); 837 838 sf.openSession(); 839 sfControl.setReturnValue(session, 1); 840 session.getSessionFactory(); 841 sessionControl.setReturnValue(sf, 1); 842 session.load(TestBean.class, "", LockMode.UPGRADE); 843 sessionControl.setReturnValue(tb, 1); 844 session.flush(); 845 sessionControl.setVoidCallable(1); 846 session.close(); 847 sessionControl.setReturnValue(null, 1); 848 sfControl.replay(); 849 sessionControl.replay(); 850 851 HibernateTemplate ht = new HibernateTemplate(sf); 852 Object result = ht.load(TestBean.class, "", LockMode.UPGRADE); 853 assertTrue("Correct result", result == tb); 854 } 855 testLoadWithEntityName()856 public void testLoadWithEntityName() throws HibernateException { 857 TestBean tb = new TestBean(); 858 859 sf.openSession(); 860 sfControl.setReturnValue(session, 1); 861 session.getSessionFactory(); 862 sessionControl.setReturnValue(sf, 1); 863 session.load("myEntity", ""); 864 sessionControl.setReturnValue(tb, 1); 865 session.flush(); 866 sessionControl.setVoidCallable(1); 867 session.close(); 868 sessionControl.setReturnValue(null, 1); 869 sfControl.replay(); 870 sessionControl.replay(); 871 872 HibernateTemplate ht = new HibernateTemplate(sf); 873 Object result = ht.load("myEntity", ""); 874 assertTrue("Correct result", result == tb); 875 } 876 testLoadWithEntityNameLockMode()877 public void testLoadWithEntityNameLockMode() throws HibernateException { 878 TestBean tb = new TestBean(); 879 880 sf.openSession(); 881 sfControl.setReturnValue(session, 1); 882 session.getSessionFactory(); 883 sessionControl.setReturnValue(sf, 1); 884 session.load("myEntity", "", LockMode.UPGRADE); 885 sessionControl.setReturnValue(tb, 1); 886 session.flush(); 887 sessionControl.setVoidCallable(1); 888 session.close(); 889 sessionControl.setReturnValue(null, 1); 890 sfControl.replay(); 891 sessionControl.replay(); 892 893 HibernateTemplate ht = new HibernateTemplate(sf); 894 Object result = ht.load("myEntity", "", LockMode.UPGRADE); 895 assertTrue("Correct result", result == tb); 896 } 897 testLoadWithObject()898 public void testLoadWithObject() throws HibernateException { 899 TestBean tb = new TestBean(); 900 sf.openSession(); 901 sfControl.setReturnValue(session, 1); 902 session.getSessionFactory(); 903 sessionControl.setReturnValue(sf, 1); 904 session.load(tb, ""); 905 sessionControl.setVoidCallable(1); 906 session.flush(); 907 sessionControl.setVoidCallable(1); 908 session.close(); 909 sessionControl.setReturnValue(null, 1); 910 sfControl.replay(); 911 sessionControl.replay(); 912 913 HibernateTemplate ht = new HibernateTemplate(sf); 914 ht.load(tb, ""); 915 } 916 testLoadAll()917 public void testLoadAll() throws HibernateException { 918 MockControl criteriaControl = MockControl.createControl(Criteria.class); 919 Criteria criteria = (Criteria) criteriaControl.getMock(); 920 List list = new ArrayList(); 921 922 sf.openSession(); 923 sfControl.setReturnValue(session, 1); 924 session.getSessionFactory(); 925 sessionControl.setReturnValue(sf, 1); 926 session.createCriteria(TestBean.class); 927 sessionControl.setReturnValue(criteria, 1); 928 criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); 929 criteriaControl.setReturnValue(criteria); 930 criteria.list(); 931 criteriaControl.setReturnValue(list, 1); 932 session.flush(); 933 sessionControl.setVoidCallable(1); 934 session.close(); 935 sessionControl.setReturnValue(null, 1); 936 sfControl.replay(); 937 sessionControl.replay(); 938 criteriaControl.replay(); 939 940 HibernateTemplate ht = new HibernateTemplate(sf); 941 List result = ht.loadAll(TestBean.class); 942 assertTrue("Correct result", result == list); 943 944 criteriaControl.verify(); 945 } 946 testLoadAllWithCacheable()947 public void testLoadAllWithCacheable() throws HibernateException { 948 MockControl criteriaControl = MockControl.createControl(Criteria.class); 949 Criteria criteria = (Criteria) criteriaControl.getMock(); 950 List list = new ArrayList(); 951 952 sf.openSession(); 953 sfControl.setReturnValue(session, 1); 954 session.getSessionFactory(); 955 sessionControl.setReturnValue(sf, 1); 956 session.createCriteria(TestBean.class); 957 sessionControl.setReturnValue(criteria, 1); 958 criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); 959 criteriaControl.setReturnValue(criteria); 960 criteria.setCacheable(true); 961 criteriaControl.setReturnValue(criteria, 1); 962 criteria.list(); 963 criteriaControl.setReturnValue(list, 1); 964 session.flush(); 965 sessionControl.setVoidCallable(1); 966 session.close(); 967 sessionControl.setReturnValue(null, 1); 968 sfControl.replay(); 969 sessionControl.replay(); 970 criteriaControl.replay(); 971 972 HibernateTemplate ht = new HibernateTemplate(sf); 973 ht.setCacheQueries(true); 974 List result = ht.loadAll(TestBean.class); 975 assertTrue("Correct result", result == list); 976 977 criteriaControl.verify(); 978 } 979 testLoadAllWithCacheableAndCacheRegion()980 public void testLoadAllWithCacheableAndCacheRegion() throws HibernateException { 981 MockControl criteriaControl = MockControl.createControl(Criteria.class); 982 Criteria criteria = (Criteria) criteriaControl.getMock(); 983 List list = new ArrayList(); 984 985 sf.openSession(); 986 sfControl.setReturnValue(session, 1); 987 session.getSessionFactory(); 988 sessionControl.setReturnValue(sf, 1); 989 session.createCriteria(TestBean.class); 990 sessionControl.setReturnValue(criteria, 1); 991 criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); 992 criteriaControl.setReturnValue(criteria); 993 criteria.setCacheable(true); 994 criteriaControl.setReturnValue(criteria, 1); 995 criteria.setCacheRegion("myCacheRegion"); 996 criteriaControl.setReturnValue(criteria, 1); 997 criteria.list(); 998 criteriaControl.setReturnValue(list, 1); 999 session.flush(); 1000 sessionControl.setVoidCallable(1); 1001 session.close(); 1002 sessionControl.setReturnValue(null, 1); 1003 sfControl.replay(); 1004 sessionControl.replay(); 1005 criteriaControl.replay(); 1006 1007 HibernateTemplate ht = new HibernateTemplate(sf); 1008 ht.setCacheQueries(true); 1009 ht.setQueryCacheRegion("myCacheRegion"); 1010 List result = ht.loadAll(TestBean.class); 1011 assertTrue("Correct result", result == list); 1012 1013 criteriaControl.verify(); 1014 } 1015 testRefresh()1016 public void testRefresh() throws HibernateException { 1017 TestBean tb = new TestBean(); 1018 sf.openSession(); 1019 sfControl.setReturnValue(session, 1); 1020 session.getSessionFactory(); 1021 sessionControl.setReturnValue(sf, 1); 1022 session.refresh(tb); 1023 sessionControl.setVoidCallable(1); 1024 session.flush(); 1025 sessionControl.setVoidCallable(1); 1026 session.close(); 1027 sessionControl.setReturnValue(null, 1); 1028 sfControl.replay(); 1029 sessionControl.replay(); 1030 1031 HibernateTemplate ht = new HibernateTemplate(sf); 1032 ht.refresh(tb); 1033 } 1034 testContains()1035 public void testContains() throws HibernateException { 1036 TestBean tb = new TestBean(); 1037 sf.openSession(); 1038 sfControl.setReturnValue(session, 1); 1039 session.getSessionFactory(); 1040 sessionControl.setReturnValue(sf, 1); 1041 session.contains(tb); 1042 sessionControl.setReturnValue(true, 1); 1043 session.flush(); 1044 sessionControl.setVoidCallable(1); 1045 session.close(); 1046 sessionControl.setReturnValue(null, 1); 1047 sfControl.replay(); 1048 sessionControl.replay(); 1049 1050 HibernateTemplate ht = new HibernateTemplate(sf); 1051 assertTrue(ht.contains(tb)); 1052 } 1053 testEvict()1054 public void testEvict() throws HibernateException { 1055 TestBean tb = new TestBean(); 1056 sf.openSession(); 1057 sfControl.setReturnValue(session, 1); 1058 session.getSessionFactory(); 1059 sessionControl.setReturnValue(sf, 1); 1060 session.evict(tb); 1061 sessionControl.setVoidCallable(1); 1062 session.flush(); 1063 sessionControl.setVoidCallable(1); 1064 session.close(); 1065 sessionControl.setReturnValue(null, 1); 1066 sfControl.replay(); 1067 sessionControl.replay(); 1068 1069 HibernateTemplate ht = new HibernateTemplate(sf); 1070 ht.evict(tb); 1071 } 1072 testLock()1073 public void testLock() throws HibernateException { 1074 TestBean tb = new TestBean(); 1075 sf.openSession(); 1076 sfControl.setReturnValue(session, 1); 1077 session.getSessionFactory(); 1078 sessionControl.setReturnValue(sf, 1); 1079 session.lock(tb, LockMode.WRITE); 1080 sessionControl.setVoidCallable(1); 1081 session.flush(); 1082 sessionControl.setVoidCallable(1); 1083 session.close(); 1084 sessionControl.setReturnValue(null, 1); 1085 sfControl.replay(); 1086 sessionControl.replay(); 1087 1088 HibernateTemplate ht = new HibernateTemplate(sf); 1089 ht.lock(tb, LockMode.WRITE); 1090 } 1091 testLockWithEntityName()1092 public void testLockWithEntityName() throws HibernateException { 1093 TestBean tb = new TestBean(); 1094 sf.openSession(); 1095 sfControl.setReturnValue(session, 1); 1096 session.getSessionFactory(); 1097 sessionControl.setReturnValue(sf, 1); 1098 session.lock("myEntity", tb, LockMode.WRITE); 1099 sessionControl.setVoidCallable(1); 1100 session.flush(); 1101 sessionControl.setVoidCallable(1); 1102 session.close(); 1103 sessionControl.setReturnValue(null, 1); 1104 sfControl.replay(); 1105 sessionControl.replay(); 1106 1107 HibernateTemplate ht = new HibernateTemplate(sf); 1108 ht.lock("myEntity", tb, LockMode.WRITE); 1109 } 1110 testSave()1111 public void testSave() throws HibernateException { 1112 TestBean tb = new TestBean(); 1113 sf.openSession(); 1114 sfControl.setReturnValue(session, 1); 1115 session.getSessionFactory(); 1116 sessionControl.setReturnValue(sf, 1); 1117 session.getFlushMode(); 1118 sessionControl.setReturnValue(FlushMode.AUTO); 1119 session.save(tb); 1120 sessionControl.setReturnValue(new Integer(0), 1); 1121 session.flush(); 1122 sessionControl.setVoidCallable(1); 1123 session.close(); 1124 sessionControl.setReturnValue(null, 1); 1125 sfControl.replay(); 1126 sessionControl.replay(); 1127 1128 HibernateTemplate ht = new HibernateTemplate(sf); 1129 assertEquals("Correct return value", ht.save(tb), new Integer(0)); 1130 } 1131 testSaveWithEntityName()1132 public void testSaveWithEntityName() throws HibernateException { 1133 TestBean tb = new TestBean(); 1134 sf.openSession(); 1135 sfControl.setReturnValue(session, 1); 1136 session.getSessionFactory(); 1137 sessionControl.setReturnValue(sf, 1); 1138 session.getFlushMode(); 1139 sessionControl.setReturnValue(FlushMode.AUTO); 1140 session.save("myEntity", tb); 1141 sessionControl.setReturnValue(new Integer(0), 1); 1142 session.flush(); 1143 sessionControl.setVoidCallable(1); 1144 session.close(); 1145 sessionControl.setReturnValue(null, 1); 1146 sfControl.replay(); 1147 sessionControl.replay(); 1148 1149 HibernateTemplate ht = new HibernateTemplate(sf); 1150 assertEquals("Correct return value", ht.save("myEntity", tb), new Integer(0)); 1151 } 1152 testUpdate()1153 public void testUpdate() throws HibernateException { 1154 TestBean tb = new TestBean(); 1155 sf.openSession(); 1156 sfControl.setReturnValue(session, 1); 1157 session.getSessionFactory(); 1158 sessionControl.setReturnValue(sf, 1); 1159 session.getFlushMode(); 1160 sessionControl.setReturnValue(FlushMode.AUTO); 1161 session.update(tb); 1162 sessionControl.setVoidCallable(1); 1163 session.flush(); 1164 sessionControl.setVoidCallable(1); 1165 session.close(); 1166 sessionControl.setReturnValue(null, 1); 1167 sfControl.replay(); 1168 sessionControl.replay(); 1169 1170 HibernateTemplate ht = new HibernateTemplate(sf); 1171 ht.update(tb); 1172 } 1173 testUpdateWithLockMode()1174 public void testUpdateWithLockMode() throws HibernateException { 1175 TestBean tb = new TestBean(); 1176 sf.openSession(); 1177 sfControl.setReturnValue(session, 1); 1178 session.getSessionFactory(); 1179 sessionControl.setReturnValue(sf, 1); 1180 session.getFlushMode(); 1181 sessionControl.setReturnValue(FlushMode.AUTO); 1182 session.update(tb); 1183 sessionControl.setVoidCallable(1); 1184 session.lock(tb, LockMode.UPGRADE); 1185 sessionControl.setVoidCallable(1); 1186 session.flush(); 1187 sessionControl.setVoidCallable(1); 1188 session.close(); 1189 sessionControl.setReturnValue(null, 1); 1190 sfControl.replay(); 1191 sessionControl.replay(); 1192 1193 HibernateTemplate ht = new HibernateTemplate(sf); 1194 ht.update(tb, LockMode.UPGRADE); 1195 } 1196 testUpdateWithEntityName()1197 public void testUpdateWithEntityName() throws HibernateException { 1198 TestBean tb = new TestBean(); 1199 sf.openSession(); 1200 sfControl.setReturnValue(session, 1); 1201 session.getSessionFactory(); 1202 sessionControl.setReturnValue(sf, 1); 1203 session.getFlushMode(); 1204 sessionControl.setReturnValue(FlushMode.AUTO); 1205 session.update("myEntity", tb); 1206 sessionControl.setVoidCallable(1); 1207 session.flush(); 1208 sessionControl.setVoidCallable(1); 1209 session.close(); 1210 sessionControl.setReturnValue(null, 1); 1211 sfControl.replay(); 1212 sessionControl.replay(); 1213 1214 HibernateTemplate ht = new HibernateTemplate(sf); 1215 ht.update("myEntity", tb); 1216 } 1217 testUpdateWithEntityNameAndLockMode()1218 public void testUpdateWithEntityNameAndLockMode() throws HibernateException { 1219 TestBean tb = new TestBean(); 1220 sf.openSession(); 1221 sfControl.setReturnValue(session, 1); 1222 session.getSessionFactory(); 1223 sessionControl.setReturnValue(sf, 1); 1224 session.getFlushMode(); 1225 sessionControl.setReturnValue(FlushMode.AUTO); 1226 session.update("myEntity", tb); 1227 sessionControl.setVoidCallable(1); 1228 session.lock(tb, LockMode.UPGRADE); 1229 sessionControl.setVoidCallable(1); 1230 session.flush(); 1231 sessionControl.setVoidCallable(1); 1232 session.close(); 1233 sessionControl.setReturnValue(null, 1); 1234 sfControl.replay(); 1235 sessionControl.replay(); 1236 1237 HibernateTemplate ht = new HibernateTemplate(sf); 1238 ht.update("myEntity", tb, LockMode.UPGRADE); 1239 } 1240 testSaveOrUpdate()1241 public void testSaveOrUpdate() throws HibernateException { 1242 TestBean tb = new TestBean(); 1243 sf.openSession(); 1244 sfControl.setReturnValue(session, 1); 1245 session.getSessionFactory(); 1246 sessionControl.setReturnValue(sf, 1); 1247 session.getFlushMode(); 1248 sessionControl.setReturnValue(FlushMode.AUTO); 1249 session.saveOrUpdate(tb); 1250 sessionControl.setVoidCallable(1); 1251 session.flush(); 1252 sessionControl.setVoidCallable(1); 1253 session.close(); 1254 sessionControl.setReturnValue(null, 1); 1255 sfControl.replay(); 1256 sessionControl.replay(); 1257 1258 HibernateTemplate ht = new HibernateTemplate(sf); 1259 ht.saveOrUpdate(tb); 1260 } 1261 testSaveOrUpdateWithFlushModeNever()1262 public void testSaveOrUpdateWithFlushModeNever() throws HibernateException { 1263 TestBean tb = new TestBean(); 1264 sf.openSession(); 1265 sfControl.setReturnValue(session, 1); 1266 session.getSessionFactory(); 1267 sessionControl.setReturnValue(sf, 1); 1268 session.getFlushMode(); 1269 sessionControl.setReturnValue(FlushMode.MANUAL); 1270 session.close(); 1271 sessionControl.setReturnValue(null, 1); 1272 sfControl.replay(); 1273 sessionControl.replay(); 1274 1275 HibernateTemplate ht = new HibernateTemplate(sf); 1276 try { 1277 ht.saveOrUpdate(tb); 1278 fail("Should have thrown InvalidDataAccessApiUsageException"); 1279 } 1280 catch (InvalidDataAccessApiUsageException ex) { 1281 // expected 1282 } 1283 } 1284 testSaveOrUpdateWithEntityName()1285 public void testSaveOrUpdateWithEntityName() throws HibernateException { 1286 TestBean tb = new TestBean(); 1287 sf.openSession(); 1288 sfControl.setReturnValue(session, 1); 1289 session.getSessionFactory(); 1290 sessionControl.setReturnValue(sf, 1); 1291 session.getFlushMode(); 1292 sessionControl.setReturnValue(FlushMode.AUTO); 1293 session.saveOrUpdate("myEntity", tb); 1294 sessionControl.setVoidCallable(1); 1295 session.flush(); 1296 sessionControl.setVoidCallable(1); 1297 session.close(); 1298 sessionControl.setReturnValue(null, 1); 1299 sfControl.replay(); 1300 sessionControl.replay(); 1301 1302 HibernateTemplate ht = new HibernateTemplate(sf); 1303 ht.saveOrUpdate("myEntity", tb); 1304 } 1305 testSaveOrUpdateAll()1306 public void testSaveOrUpdateAll() throws HibernateException { 1307 TestBean tb1 = new TestBean(); 1308 TestBean tb2 = new TestBean(); 1309 sf.openSession(); 1310 sfControl.setReturnValue(session, 1); 1311 session.getSessionFactory(); 1312 sessionControl.setReturnValue(sf, 1); 1313 session.getFlushMode(); 1314 sessionControl.setReturnValue(FlushMode.AUTO); 1315 session.saveOrUpdate(tb1); 1316 sessionControl.setVoidCallable(1); 1317 session.saveOrUpdate(tb2); 1318 sessionControl.setVoidCallable(1); 1319 session.flush(); 1320 sessionControl.setVoidCallable(1); 1321 session.close(); 1322 sessionControl.setReturnValue(null, 1); 1323 sfControl.replay(); 1324 sessionControl.replay(); 1325 1326 HibernateTemplate ht = new HibernateTemplate(sf); 1327 List tbs = new ArrayList(); 1328 tbs.add(tb1); 1329 tbs.add(tb2); 1330 ht.saveOrUpdateAll(tbs); 1331 } 1332 testReplicate()1333 public void testReplicate() throws HibernateException { 1334 TestBean tb = new TestBean(); 1335 sf.openSession(); 1336 sfControl.setReturnValue(session, 1); 1337 session.getSessionFactory(); 1338 sessionControl.setReturnValue(sf, 1); 1339 session.getFlushMode(); 1340 sessionControl.setReturnValue(FlushMode.AUTO); 1341 session.replicate(tb, ReplicationMode.LATEST_VERSION); 1342 sessionControl.setVoidCallable(1); 1343 session.flush(); 1344 sessionControl.setVoidCallable(1); 1345 session.close(); 1346 sessionControl.setReturnValue(null, 1); 1347 sfControl.replay(); 1348 sessionControl.replay(); 1349 1350 HibernateTemplate ht = new HibernateTemplate(sf); 1351 ht.replicate(tb, ReplicationMode.LATEST_VERSION); 1352 } 1353 testReplicateWithEntityName()1354 public void testReplicateWithEntityName() throws HibernateException { 1355 TestBean tb = new TestBean(); 1356 sf.openSession(); 1357 sfControl.setReturnValue(session, 1); 1358 session.getSessionFactory(); 1359 sessionControl.setReturnValue(sf, 1); 1360 session.getFlushMode(); 1361 sessionControl.setReturnValue(FlushMode.AUTO); 1362 session.replicate("myEntity", tb, ReplicationMode.LATEST_VERSION); 1363 sessionControl.setVoidCallable(1); 1364 session.flush(); 1365 sessionControl.setVoidCallable(1); 1366 session.close(); 1367 sessionControl.setReturnValue(null, 1); 1368 sfControl.replay(); 1369 sessionControl.replay(); 1370 1371 HibernateTemplate ht = new HibernateTemplate(sf); 1372 ht.replicate("myEntity", tb, ReplicationMode.LATEST_VERSION); 1373 } 1374 testPersist()1375 public void testPersist() throws HibernateException { 1376 TestBean tb = new TestBean(); 1377 sf.openSession(); 1378 sfControl.setReturnValue(session, 1); 1379 session.getSessionFactory(); 1380 sessionControl.setReturnValue(sf, 1); 1381 session.getFlushMode(); 1382 sessionControl.setReturnValue(FlushMode.AUTO); 1383 session.persist(tb); 1384 sessionControl.setVoidCallable(1); 1385 session.flush(); 1386 sessionControl.setVoidCallable(1); 1387 session.close(); 1388 sessionControl.setReturnValue(null, 1); 1389 sfControl.replay(); 1390 sessionControl.replay(); 1391 1392 HibernateTemplate ht = new HibernateTemplate(sf); 1393 ht.persist(tb); 1394 } 1395 testPersistWithEntityName()1396 public void testPersistWithEntityName() throws HibernateException { 1397 TestBean tb = new TestBean(); 1398 sf.openSession(); 1399 sfControl.setReturnValue(session, 1); 1400 session.getSessionFactory(); 1401 sessionControl.setReturnValue(sf, 1); 1402 session.getFlushMode(); 1403 sessionControl.setReturnValue(FlushMode.AUTO); 1404 session.persist("myEntity", tb); 1405 sessionControl.setVoidCallable(1); 1406 session.flush(); 1407 sessionControl.setVoidCallable(1); 1408 session.close(); 1409 sessionControl.setReturnValue(null, 1); 1410 sfControl.replay(); 1411 sessionControl.replay(); 1412 1413 HibernateTemplate ht = new HibernateTemplate(sf); 1414 ht.persist("myEntity", tb); 1415 } 1416 testMerge()1417 public void testMerge() throws HibernateException { 1418 TestBean tb = new TestBean(); 1419 TestBean tbMerged = new TestBean(); 1420 sf.openSession(); 1421 sfControl.setReturnValue(session, 1); 1422 session.getSessionFactory(); 1423 sessionControl.setReturnValue(sf, 1); 1424 session.getFlushMode(); 1425 sessionControl.setReturnValue(FlushMode.AUTO); 1426 session.merge(tb); 1427 sessionControl.setReturnValue(tbMerged, 1); 1428 session.flush(); 1429 sessionControl.setVoidCallable(1); 1430 session.close(); 1431 sessionControl.setReturnValue(null, 1); 1432 sfControl.replay(); 1433 sessionControl.replay(); 1434 1435 HibernateTemplate ht = new HibernateTemplate(sf); 1436 assertSame(tbMerged, ht.merge(tb)); 1437 } 1438 testMergeWithEntityName()1439 public void testMergeWithEntityName() throws HibernateException { 1440 TestBean tb = new TestBean(); 1441 TestBean tbMerged = new TestBean(); 1442 sf.openSession(); 1443 sfControl.setReturnValue(session, 1); 1444 session.getSessionFactory(); 1445 sessionControl.setReturnValue(sf, 1); 1446 session.getFlushMode(); 1447 sessionControl.setReturnValue(FlushMode.AUTO); 1448 session.merge("myEntity", tb); 1449 sessionControl.setReturnValue(tbMerged, 1); 1450 session.flush(); 1451 sessionControl.setVoidCallable(1); 1452 session.close(); 1453 sessionControl.setReturnValue(null, 1); 1454 sfControl.replay(); 1455 sessionControl.replay(); 1456 1457 HibernateTemplate ht = new HibernateTemplate(sf); 1458 assertSame(tbMerged, ht.merge("myEntity", tb)); 1459 } 1460 testDelete()1461 public void testDelete() throws HibernateException { 1462 TestBean tb = new TestBean(); 1463 sf.openSession(); 1464 sfControl.setReturnValue(session, 1); 1465 session.getSessionFactory(); 1466 sessionControl.setReturnValue(sf, 1); 1467 session.getFlushMode(); 1468 sessionControl.setReturnValue(FlushMode.AUTO); 1469 session.delete(tb); 1470 sessionControl.setVoidCallable(1); 1471 session.flush(); 1472 sessionControl.setVoidCallable(1); 1473 session.close(); 1474 sessionControl.setReturnValue(null, 1); 1475 sfControl.replay(); 1476 sessionControl.replay(); 1477 1478 HibernateTemplate ht = new HibernateTemplate(sf); 1479 ht.delete(tb); 1480 } 1481 testDeleteWithLockMode()1482 public void testDeleteWithLockMode() throws HibernateException { 1483 TestBean tb = new TestBean(); 1484 sf.openSession(); 1485 sfControl.setReturnValue(session, 1); 1486 session.getSessionFactory(); 1487 sessionControl.setReturnValue(sf, 1); 1488 session.getFlushMode(); 1489 sessionControl.setReturnValue(FlushMode.AUTO); 1490 session.lock(tb, LockMode.UPGRADE); 1491 sessionControl.setVoidCallable(1); 1492 session.delete(tb); 1493 sessionControl.setVoidCallable(1); 1494 session.flush(); 1495 sessionControl.setVoidCallable(1); 1496 session.close(); 1497 sessionControl.setReturnValue(null, 1); 1498 sfControl.replay(); 1499 sessionControl.replay(); 1500 1501 HibernateTemplate ht = new HibernateTemplate(sf); 1502 ht.delete(tb, LockMode.UPGRADE); 1503 } 1504 testDeleteWithEntityName()1505 public void testDeleteWithEntityName() throws HibernateException { 1506 TestBean tb = new TestBean(); 1507 sf.openSession(); 1508 sfControl.setReturnValue(session, 1); 1509 session.getSessionFactory(); 1510 sessionControl.setReturnValue(sf, 1); 1511 session.getFlushMode(); 1512 sessionControl.setReturnValue(FlushMode.AUTO); 1513 session.delete("myEntity", tb); 1514 sessionControl.setVoidCallable(1); 1515 session.flush(); 1516 sessionControl.setVoidCallable(1); 1517 session.close(); 1518 sessionControl.setReturnValue(null, 1); 1519 sfControl.replay(); 1520 sessionControl.replay(); 1521 1522 HibernateTemplate ht = new HibernateTemplate(sf); 1523 ht.delete("myEntity", tb); 1524 } 1525 testDeleteWithEntityNameAndLockMode()1526 public void testDeleteWithEntityNameAndLockMode() throws HibernateException { 1527 TestBean tb = new TestBean(); 1528 sf.openSession(); 1529 sfControl.setReturnValue(session, 1); 1530 session.getSessionFactory(); 1531 sessionControl.setReturnValue(sf, 1); 1532 session.getFlushMode(); 1533 sessionControl.setReturnValue(FlushMode.AUTO); 1534 session.lock("myEntity", tb, LockMode.UPGRADE); 1535 sessionControl.setVoidCallable(1); 1536 session.delete("myEntity", tb); 1537 sessionControl.setVoidCallable(1); 1538 session.flush(); 1539 sessionControl.setVoidCallable(1); 1540 session.close(); 1541 sessionControl.setReturnValue(null, 1); 1542 sfControl.replay(); 1543 sessionControl.replay(); 1544 1545 HibernateTemplate ht = new HibernateTemplate(sf); 1546 ht.delete("myEntity", tb, LockMode.UPGRADE); 1547 } 1548 testDeleteAll()1549 public void testDeleteAll() throws HibernateException { 1550 TestBean tb1 = new TestBean(); 1551 TestBean tb2 = new TestBean(); 1552 sf.openSession(); 1553 sfControl.setReturnValue(session, 1); 1554 session.getSessionFactory(); 1555 sessionControl.setReturnValue(sf, 1); 1556 session.getFlushMode(); 1557 sessionControl.setReturnValue(FlushMode.AUTO); 1558 session.delete(tb1); 1559 sessionControl.setVoidCallable(1); 1560 session.delete(tb2); 1561 sessionControl.setVoidCallable(1); 1562 session.flush(); 1563 sessionControl.setVoidCallable(1); 1564 session.close(); 1565 sessionControl.setReturnValue(null, 1); 1566 sfControl.replay(); 1567 sessionControl.replay(); 1568 1569 HibernateTemplate ht = new HibernateTemplate(sf); 1570 List tbs = new ArrayList(); 1571 tbs.add(tb1); 1572 tbs.add(tb2); 1573 ht.deleteAll(tbs); 1574 } 1575 testFlush()1576 public void testFlush() throws HibernateException { 1577 sf.openSession(); 1578 sfControl.setReturnValue(session, 1); 1579 session.getSessionFactory(); 1580 sessionControl.setReturnValue(sf, 1); 1581 session.setFlushMode(FlushMode.MANUAL); 1582 sessionControl.setVoidCallable(1); 1583 session.flush(); 1584 sessionControl.setVoidCallable(1); 1585 session.close(); 1586 sessionControl.setReturnValue(null, 1); 1587 sfControl.replay(); 1588 sessionControl.replay(); 1589 1590 HibernateTemplate ht = new HibernateTemplate(sf); 1591 ht.setFlushMode(HibernateTemplate.FLUSH_NEVER); 1592 ht.flush(); 1593 } 1594 testClear()1595 public void testClear() throws HibernateException { 1596 sf.openSession(); 1597 sfControl.setReturnValue(session, 1); 1598 session.getSessionFactory(); 1599 sessionControl.setReturnValue(sf, 1); 1600 session.clear(); 1601 sessionControl.setVoidCallable(1); 1602 session.flush(); 1603 sessionControl.setVoidCallable(1); 1604 session.close(); 1605 sessionControl.setReturnValue(null, 1); 1606 sfControl.replay(); 1607 sessionControl.replay(); 1608 1609 HibernateTemplate ht = new HibernateTemplate(sf); 1610 ht.clear(); 1611 } 1612 testFind()1613 public void testFind() throws HibernateException { 1614 MockControl queryControl = MockControl.createControl(Query.class); 1615 Query query = (Query) queryControl.getMock(); 1616 1617 List list = new ArrayList(); 1618 sf.openSession(); 1619 sfControl.setReturnValue(session, 1); 1620 session.getSessionFactory(); 1621 sessionControl.setReturnValue(sf, 1); 1622 session.createQuery("some query string"); 1623 sessionControl.setReturnValue(query, 1); 1624 query.list(); 1625 queryControl.setReturnValue(list, 1); 1626 session.flush(); 1627 sessionControl.setVoidCallable(1); 1628 session.close(); 1629 sessionControl.setReturnValue(null, 1); 1630 sfControl.replay(); 1631 sessionControl.replay(); 1632 queryControl.replay(); 1633 1634 HibernateTemplate ht = new HibernateTemplate(sf); 1635 List result = ht.find("some query string"); 1636 assertTrue("Correct list", result == list); 1637 queryControl.verify(); 1638 } 1639 testFindWithParameter()1640 public void testFindWithParameter() throws HibernateException { 1641 MockControl queryControl = MockControl.createControl(Query.class); 1642 Query query = (Query) queryControl.getMock(); 1643 1644 List list = new ArrayList(); 1645 sf.openSession(); 1646 sfControl.setReturnValue(session, 1); 1647 session.getSessionFactory(); 1648 sessionControl.setReturnValue(sf, 1); 1649 session.createQuery("some query string"); 1650 sessionControl.setReturnValue(query, 1); 1651 query.setParameter(0, "myvalue"); 1652 queryControl.setReturnValue(query, 1); 1653 query.list(); 1654 queryControl.setReturnValue(list, 1); 1655 session.flush(); 1656 sessionControl.setVoidCallable(1); 1657 session.close(); 1658 sessionControl.setReturnValue(null, 1); 1659 sfControl.replay(); 1660 sessionControl.replay(); 1661 queryControl.replay(); 1662 1663 HibernateTemplate ht = new HibernateTemplate(sf); 1664 List result = ht.find("some query string", "myvalue"); 1665 assertTrue("Correct list", result == list); 1666 queryControl.verify(); 1667 } 1668 testFindWithParameters()1669 public void testFindWithParameters() throws HibernateException { 1670 MockControl queryControl = MockControl.createControl(Query.class); 1671 Query query = (Query) queryControl.getMock(); 1672 1673 List list = new ArrayList(); 1674 sf.openSession(); 1675 sfControl.setReturnValue(session, 1); 1676 session.getSessionFactory(); 1677 sessionControl.setReturnValue(sf, 1); 1678 session.createQuery("some query string"); 1679 sessionControl.setReturnValue(query, 1); 1680 query.setParameter(0, "myvalue1"); 1681 queryControl.setReturnValue(query, 1); 1682 query.setParameter(1, new Integer(2)); 1683 queryControl.setReturnValue(query, 1); 1684 query.list(); 1685 queryControl.setReturnValue(list, 1); 1686 session.flush(); 1687 sessionControl.setVoidCallable(1); 1688 session.close(); 1689 sessionControl.setReturnValue(null, 1); 1690 sfControl.replay(); 1691 sessionControl.replay(); 1692 queryControl.replay(); 1693 1694 HibernateTemplate ht = new HibernateTemplate(sf); 1695 List result = ht.find("some query string", new Object[] {"myvalue1", new Integer(2)}); 1696 assertTrue("Correct list", result == list); 1697 queryControl.verify(); 1698 } 1699 testFindWithNamedParameter()1700 public void testFindWithNamedParameter() throws HibernateException { 1701 MockControl queryControl = MockControl.createControl(Query.class); 1702 Query query = (Query) queryControl.getMock(); 1703 1704 List list = new ArrayList(); 1705 sf.openSession(); 1706 sfControl.setReturnValue(session, 1); 1707 session.getSessionFactory(); 1708 sessionControl.setReturnValue(sf, 1); 1709 session.createQuery("some query string"); 1710 sessionControl.setReturnValue(query, 1); 1711 query.setParameter("myparam", "myvalue"); 1712 queryControl.setReturnValue(query, 1); 1713 query.list(); 1714 queryControl.setReturnValue(list, 1); 1715 session.flush(); 1716 sessionControl.setVoidCallable(1); 1717 session.close(); 1718 sessionControl.setReturnValue(null, 1); 1719 sfControl.replay(); 1720 sessionControl.replay(); 1721 queryControl.replay(); 1722 1723 HibernateTemplate ht = new HibernateTemplate(sf); 1724 List result = ht.findByNamedParam("some query string", "myparam", "myvalue"); 1725 assertTrue("Correct list", result == list); 1726 queryControl.verify(); 1727 } 1728 testFindWithNamedParameters()1729 public void testFindWithNamedParameters() throws HibernateException { 1730 MockControl queryControl = MockControl.createControl(Query.class); 1731 Query query = (Query) queryControl.getMock(); 1732 1733 List list = new ArrayList(); 1734 sf.openSession(); 1735 sfControl.setReturnValue(session, 1); 1736 session.getSessionFactory(); 1737 sessionControl.setReturnValue(sf, 1); 1738 session.createQuery("some query string"); 1739 sessionControl.setReturnValue(query, 1); 1740 query.setParameter("myparam1", "myvalue1"); 1741 queryControl.setReturnValue(query, 1); 1742 query.setParameter("myparam2", new Integer(2)); 1743 queryControl.setReturnValue(query, 1); 1744 query.list(); 1745 queryControl.setReturnValue(list, 1); 1746 session.flush(); 1747 sessionControl.setVoidCallable(1); 1748 session.close(); 1749 sessionControl.setReturnValue(null, 1); 1750 sfControl.replay(); 1751 sessionControl.replay(); 1752 queryControl.replay(); 1753 1754 HibernateTemplate ht = new HibernateTemplate(sf); 1755 List result = ht.findByNamedParam("some query string", 1756 new String[] {"myparam1", "myparam2"}, 1757 new Object[] {"myvalue1", new Integer(2)}); 1758 assertTrue("Correct list", result == list); 1759 queryControl.verify(); 1760 } 1761 testFindByValueBean()1762 public void testFindByValueBean() throws HibernateException { 1763 MockControl queryControl = MockControl.createControl(Query.class); 1764 Query query = (Query) queryControl.getMock(); 1765 1766 TestBean tb = new TestBean(); 1767 List list = new ArrayList(); 1768 sf.openSession(); 1769 sfControl.setReturnValue(session, 1); 1770 session.getSessionFactory(); 1771 sessionControl.setReturnValue(sf, 1); 1772 session.createQuery("some query string"); 1773 sessionControl.setReturnValue(query, 1); 1774 query.setProperties(tb); 1775 queryControl.setReturnValue(query, 1); 1776 query.list(); 1777 queryControl.setReturnValue(list, 1); 1778 session.flush(); 1779 sessionControl.setVoidCallable(1); 1780 session.close(); 1781 sessionControl.setReturnValue(null, 1); 1782 sfControl.replay(); 1783 sessionControl.replay(); 1784 queryControl.replay(); 1785 1786 HibernateTemplate ht = new HibernateTemplate(sf); 1787 List result = ht.findByValueBean("some query string", tb); 1788 assertTrue("Correct list", result == list); 1789 queryControl.verify(); 1790 } 1791 testFindByNamedQuery()1792 public void testFindByNamedQuery() throws HibernateException { 1793 MockControl queryControl = MockControl.createControl(Query.class); 1794 Query query = (Query) queryControl.getMock(); 1795 1796 List list = new ArrayList(); 1797 sf.openSession(); 1798 sfControl.setReturnValue(session, 1); 1799 session.getSessionFactory(); 1800 sessionControl.setReturnValue(sf, 1); 1801 session.getNamedQuery("some query name"); 1802 sessionControl.setReturnValue(query, 1); 1803 query.list(); 1804 queryControl.setReturnValue(list, 1); 1805 session.flush(); 1806 sessionControl.setVoidCallable(1); 1807 session.close(); 1808 sessionControl.setReturnValue(null, 1); 1809 sfControl.replay(); 1810 sessionControl.replay(); 1811 queryControl.replay(); 1812 1813 HibernateTemplate ht = new HibernateTemplate(sf); 1814 List result = ht.findByNamedQuery("some query name"); 1815 assertTrue("Correct list", result == list); 1816 queryControl.verify(); 1817 } 1818 testFindByNamedQueryWithParameter()1819 public void testFindByNamedQueryWithParameter() throws HibernateException { 1820 MockControl queryControl = MockControl.createControl(Query.class); 1821 Query query = (Query) queryControl.getMock(); 1822 1823 List list = new ArrayList(); 1824 sf.openSession(); 1825 sfControl.setReturnValue(session, 1); 1826 session.getSessionFactory(); 1827 sessionControl.setReturnValue(sf, 1); 1828 session.getNamedQuery("some query name"); 1829 sessionControl.setReturnValue(query, 1); 1830 query.setParameter(0, "myvalue"); 1831 queryControl.setReturnValue(query, 1); 1832 query.list(); 1833 queryControl.setReturnValue(list, 1); 1834 session.flush(); 1835 sessionControl.setVoidCallable(1); 1836 session.close(); 1837 sessionControl.setReturnValue(null, 1); 1838 sfControl.replay(); 1839 sessionControl.replay(); 1840 queryControl.replay(); 1841 1842 HibernateTemplate ht = new HibernateTemplate(sf); 1843 List result = ht.findByNamedQuery("some query name", "myvalue"); 1844 assertTrue("Correct list", result == list); 1845 queryControl.verify(); 1846 } 1847 testFindByNamedQueryWithParameters()1848 public void testFindByNamedQueryWithParameters() throws HibernateException { 1849 MockControl queryControl = MockControl.createControl(Query.class); 1850 Query query = (Query) queryControl.getMock(); 1851 1852 List list = new ArrayList(); 1853 sf.openSession(); 1854 sfControl.setReturnValue(session, 1); 1855 session.getSessionFactory(); 1856 sessionControl.setReturnValue(sf, 1); 1857 session.getNamedQuery("some query name"); 1858 sessionControl.setReturnValue(query, 1); 1859 query.setParameter(0, "myvalue1"); 1860 queryControl.setReturnValue(query, 1); 1861 query.setParameter(1, new Integer(2)); 1862 queryControl.setReturnValue(query, 1); 1863 query.list(); 1864 queryControl.setReturnValue(list, 1); 1865 session.flush(); 1866 sessionControl.setVoidCallable(1); 1867 session.close(); 1868 sessionControl.setReturnValue(null, 1); 1869 sfControl.replay(); 1870 sessionControl.replay(); 1871 queryControl.replay(); 1872 1873 HibernateTemplate ht = new HibernateTemplate(sf); 1874 List result = ht.findByNamedQuery("some query name", new Object[] {"myvalue1", new Integer(2)}); 1875 assertTrue("Correct list", result == list); 1876 queryControl.verify(); 1877 } 1878 testFindByNamedQueryWithNamedParameter()1879 public void testFindByNamedQueryWithNamedParameter() throws HibernateException { 1880 MockControl queryControl = MockControl.createControl(Query.class); 1881 Query query = (Query) queryControl.getMock(); 1882 1883 List list = new ArrayList(); 1884 sf.openSession(); 1885 sfControl.setReturnValue(session, 1); 1886 session.getSessionFactory(); 1887 sessionControl.setReturnValue(sf, 1); 1888 session.getNamedQuery("some query name"); 1889 sessionControl.setReturnValue(query, 1); 1890 query.setParameter("myparam", "myvalue"); 1891 queryControl.setReturnValue(query, 1); 1892 query.list(); 1893 queryControl.setReturnValue(list, 1); 1894 session.flush(); 1895 sessionControl.setVoidCallable(1); 1896 session.close(); 1897 sessionControl.setReturnValue(null, 1); 1898 sfControl.replay(); 1899 sessionControl.replay(); 1900 queryControl.replay(); 1901 1902 HibernateTemplate ht = new HibernateTemplate(sf); 1903 List result = ht.findByNamedQueryAndNamedParam("some query name", "myparam", "myvalue"); 1904 assertTrue("Correct list", result == list); 1905 queryControl.verify(); 1906 } 1907 testFindByNamedQueryWithNamedParameters()1908 public void testFindByNamedQueryWithNamedParameters() throws HibernateException { 1909 MockControl queryControl = MockControl.createControl(Query.class); 1910 Query query = (Query) queryControl.getMock(); 1911 1912 List list = new ArrayList(); 1913 sf.openSession(); 1914 sfControl.setReturnValue(session, 1); 1915 session.getSessionFactory(); 1916 sessionControl.setReturnValue(sf, 1); 1917 session.getNamedQuery("some query name"); 1918 sessionControl.setReturnValue(query, 1); 1919 query.setParameter("myparam1", "myvalue1"); 1920 queryControl.setReturnValue(query, 1); 1921 query.setParameter("myparam2", new Integer(2)); 1922 queryControl.setReturnValue(query, 1); 1923 query.list(); 1924 queryControl.setReturnValue(list, 1); 1925 session.flush(); 1926 sessionControl.setVoidCallable(1); 1927 session.close(); 1928 sessionControl.setReturnValue(null, 1); 1929 sfControl.replay(); 1930 sessionControl.replay(); 1931 queryControl.replay(); 1932 1933 HibernateTemplate ht = new HibernateTemplate(sf); 1934 List result = ht.findByNamedQueryAndNamedParam("some query name", 1935 new String[] {"myparam1", "myparam2"}, 1936 new Object[] {"myvalue1", new Integer(2)}); 1937 assertTrue("Correct list", result == list); 1938 queryControl.verify(); 1939 } 1940 testFindByNamedQueryAndValueBean()1941 public void testFindByNamedQueryAndValueBean() throws HibernateException { 1942 MockControl queryControl = MockControl.createControl(Query.class); 1943 Query query = (Query) queryControl.getMock(); 1944 1945 TestBean tb = new TestBean(); 1946 List list = new ArrayList(); 1947 sf.openSession(); 1948 sfControl.setReturnValue(session, 1); 1949 session.getSessionFactory(); 1950 sessionControl.setReturnValue(sf, 1); 1951 session.getNamedQuery("some query name"); 1952 sessionControl.setReturnValue(query, 1); 1953 query.setProperties(tb); 1954 queryControl.setReturnValue(query, 1); 1955 query.list(); 1956 queryControl.setReturnValue(list, 1); 1957 session.flush(); 1958 sessionControl.setVoidCallable(1); 1959 session.close(); 1960 sessionControl.setReturnValue(null, 1); 1961 sfControl.replay(); 1962 sessionControl.replay(); 1963 queryControl.replay(); 1964 1965 HibernateTemplate ht = new HibernateTemplate(sf); 1966 List result = ht.findByNamedQueryAndValueBean("some query name", tb); 1967 assertTrue("Correct list", result == list); 1968 queryControl.verify(); 1969 } 1970 testFindWithCacheable()1971 public void testFindWithCacheable() throws HibernateException { 1972 MockControl queryControl = MockControl.createControl(Query.class); 1973 Query query = (Query) queryControl.getMock(); 1974 1975 List list = new ArrayList(); 1976 sf.openSession(); 1977 sfControl.setReturnValue(session, 1); 1978 session.getSessionFactory(); 1979 sessionControl.setReturnValue(sf, 1); 1980 session.createQuery("some query string"); 1981 sessionControl.setReturnValue(query, 1); 1982 query.setCacheable(true); 1983 queryControl.setReturnValue(query, 1); 1984 query.list(); 1985 queryControl.setReturnValue(list, 1); 1986 session.flush(); 1987 sessionControl.setVoidCallable(1); 1988 session.close(); 1989 sessionControl.setReturnValue(null, 1); 1990 sfControl.replay(); 1991 sessionControl.replay(); 1992 queryControl.replay(); 1993 1994 HibernateTemplate ht = new HibernateTemplate(sf); 1995 ht.setCacheQueries(true); 1996 List result = ht.find("some query string"); 1997 assertTrue("Correct list", result == list); 1998 sfControl.verify(); 1999 } 2000 testFindWithCacheableAndCacheRegion()2001 public void testFindWithCacheableAndCacheRegion() throws HibernateException { 2002 MockControl queryControl = MockControl.createControl(Query.class); 2003 Query query = (Query) queryControl.getMock(); 2004 2005 List list = new ArrayList(); 2006 sf.openSession(); 2007 sfControl.setReturnValue(session, 1); 2008 session.getSessionFactory(); 2009 sessionControl.setReturnValue(sf, 1); 2010 session.createQuery("some query string"); 2011 sessionControl.setReturnValue(query, 1); 2012 query.setCacheable(true); 2013 queryControl.setReturnValue(query, 1); 2014 query.setCacheRegion("myCacheRegion"); 2015 queryControl.setReturnValue(query, 1); 2016 query.list(); 2017 queryControl.setReturnValue(list, 1); 2018 session.flush(); 2019 sessionControl.setVoidCallable(1); 2020 session.close(); 2021 sessionControl.setReturnValue(null, 1); 2022 sfControl.replay(); 2023 sessionControl.replay(); 2024 queryControl.replay(); 2025 2026 HibernateTemplate ht = new HibernateTemplate(sf); 2027 ht.setCacheQueries(true); 2028 ht.setQueryCacheRegion("myCacheRegion"); 2029 List result = ht.find("some query string"); 2030 assertTrue("Correct list", result == list); 2031 sfControl.verify(); 2032 } 2033 testFindByNamedQueryWithCacheable()2034 public void testFindByNamedQueryWithCacheable() throws HibernateException { 2035 MockControl queryControl = MockControl.createControl(Query.class); 2036 Query query = (Query) queryControl.getMock(); 2037 2038 List list = new ArrayList(); 2039 sf.openSession(); 2040 sfControl.setReturnValue(session, 1); 2041 session.getSessionFactory(); 2042 sessionControl.setReturnValue(sf, 1); 2043 session.getNamedQuery("some query name"); 2044 sessionControl.setReturnValue(query, 1); 2045 query.setCacheable(true); 2046 queryControl.setReturnValue(query, 1); 2047 query.list(); 2048 queryControl.setReturnValue(list, 1); 2049 session.flush(); 2050 sessionControl.setVoidCallable(1); 2051 session.close(); 2052 sessionControl.setReturnValue(null, 1); 2053 sfControl.replay(); 2054 sessionControl.replay(); 2055 queryControl.replay(); 2056 2057 HibernateTemplate ht = new HibernateTemplate(sf); 2058 ht.setCacheQueries(true); 2059 List result = ht.findByNamedQuery("some query name"); 2060 assertTrue("Correct list", result == list); 2061 queryControl.verify(); 2062 } 2063 testFindByNamedQueryWithCacheableAndCacheRegion()2064 public void testFindByNamedQueryWithCacheableAndCacheRegion() throws HibernateException { 2065 MockControl queryControl = MockControl.createControl(Query.class); 2066 Query query = (Query) queryControl.getMock(); 2067 2068 List list = new ArrayList(); 2069 sf.openSession(); 2070 sfControl.setReturnValue(session, 1); 2071 session.getSessionFactory(); 2072 sessionControl.setReturnValue(sf, 1); 2073 session.getNamedQuery("some query name"); 2074 sessionControl.setReturnValue(query, 1); 2075 query.setCacheable(true); 2076 queryControl.setReturnValue(query, 1); 2077 query.setCacheRegion("myCacheRegion"); 2078 queryControl.setReturnValue(query, 1); 2079 query.list(); 2080 queryControl.setReturnValue(list, 1); 2081 session.flush(); 2082 sessionControl.setVoidCallable(1); 2083 session.close(); 2084 sessionControl.setReturnValue(null, 1); 2085 sfControl.replay(); 2086 sessionControl.replay(); 2087 queryControl.replay(); 2088 2089 HibernateTemplate ht = new HibernateTemplate(sf); 2090 ht.setCacheQueries(true); 2091 ht.setQueryCacheRegion("myCacheRegion"); 2092 List result = ht.findByNamedQuery("some query name"); 2093 assertTrue("Correct list", result == list); 2094 queryControl.verify(); 2095 } 2096 testIterate()2097 public void testIterate() throws HibernateException { 2098 MockControl queryControl = MockControl.createControl(Query.class); 2099 Query query = (Query) queryControl.getMock(); 2100 2101 Iterator it = Collections.EMPTY_LIST.iterator(); 2102 sf.openSession(); 2103 sfControl.setReturnValue(session, 1); 2104 session.getSessionFactory(); 2105 sessionControl.setReturnValue(sf, 1); 2106 session.createQuery("some query string"); 2107 sessionControl.setReturnValue(query, 1); 2108 query.iterate(); 2109 queryControl.setReturnValue(it, 1); 2110 session.flush(); 2111 sessionControl.setVoidCallable(1); 2112 session.close(); 2113 sessionControl.setReturnValue(null, 1); 2114 sfControl.replay(); 2115 sessionControl.replay(); 2116 queryControl.replay(); 2117 2118 HibernateTemplate ht = new HibernateTemplate(sf); 2119 Iterator result = ht.iterate("some query string"); 2120 assertTrue("Correct list", result == it); 2121 queryControl.verify(); 2122 } 2123 testIterateWithParameter()2124 public void testIterateWithParameter() throws HibernateException { 2125 MockControl queryControl = MockControl.createControl(Query.class); 2126 Query query = (Query) queryControl.getMock(); 2127 2128 Iterator it = Collections.EMPTY_LIST.iterator(); 2129 sf.openSession(); 2130 sfControl.setReturnValue(session, 1); 2131 session.getSessionFactory(); 2132 sessionControl.setReturnValue(sf, 1); 2133 session.createQuery("some query string"); 2134 sessionControl.setReturnValue(query, 1); 2135 query.setParameter(0, "myvalue"); 2136 queryControl.setReturnValue(query, 1); 2137 query.iterate(); 2138 queryControl.setReturnValue(it, 1); 2139 session.flush(); 2140 sessionControl.setVoidCallable(1); 2141 session.close(); 2142 sessionControl.setReturnValue(null, 1); 2143 sfControl.replay(); 2144 sessionControl.replay(); 2145 queryControl.replay(); 2146 2147 HibernateTemplate ht = new HibernateTemplate(sf); 2148 Iterator result = ht.iterate("some query string", "myvalue"); 2149 assertTrue("Correct list", result == it); 2150 queryControl.verify(); 2151 } 2152 testIterateWithParameters()2153 public void testIterateWithParameters() throws HibernateException { 2154 MockControl queryControl = MockControl.createControl(Query.class); 2155 Query query = (Query) queryControl.getMock(); 2156 2157 Iterator it = Collections.EMPTY_LIST.iterator(); 2158 sf.openSession(); 2159 sfControl.setReturnValue(session, 1); 2160 session.getSessionFactory(); 2161 sessionControl.setReturnValue(sf, 1); 2162 session.createQuery("some query string"); 2163 sessionControl.setReturnValue(query, 1); 2164 query.setParameter(0, "myvalue1"); 2165 queryControl.setReturnValue(query, 1); 2166 query.setParameter(1, new Integer(2)); 2167 queryControl.setReturnValue(query, 1); 2168 query.iterate(); 2169 queryControl.setReturnValue(it, 1); 2170 session.flush(); 2171 sessionControl.setVoidCallable(1); 2172 session.close(); 2173 sessionControl.setReturnValue(null, 1); 2174 sfControl.replay(); 2175 sessionControl.replay(); 2176 queryControl.replay(); 2177 2178 HibernateTemplate ht = new HibernateTemplate(sf); 2179 Iterator result = ht.iterate("some query string", 2180 new Object[] {"myvalue1", new Integer(2)}); 2181 assertTrue("Correct list", result == it); 2182 sfControl.verify(); 2183 } 2184 testBulkUpdate()2185 public void testBulkUpdate() throws HibernateException { 2186 MockControl queryControl = MockControl.createControl(Query.class); 2187 Query query = (Query) queryControl.getMock(); 2188 2189 sf.openSession(); 2190 sfControl.setReturnValue(session, 1); 2191 session.getSessionFactory(); 2192 sessionControl.setReturnValue(sf, 1); 2193 session.createQuery("some query string"); 2194 sessionControl.setReturnValue(query, 1); 2195 query.executeUpdate(); 2196 queryControl.setReturnValue(5, 1); 2197 session.flush(); 2198 sessionControl.setVoidCallable(1); 2199 session.close(); 2200 sessionControl.setReturnValue(null, 1); 2201 sfControl.replay(); 2202 sessionControl.replay(); 2203 queryControl.replay(); 2204 2205 HibernateTemplate ht = new HibernateTemplate(sf); 2206 int result = ht.bulkUpdate("some query string"); 2207 assertTrue("Correct list", result == 5); 2208 queryControl.verify(); 2209 } 2210 testBulkUpdateWithParameter()2211 public void testBulkUpdateWithParameter() throws HibernateException { 2212 MockControl queryControl = MockControl.createControl(Query.class); 2213 Query query = (Query) queryControl.getMock(); 2214 2215 sf.openSession(); 2216 sfControl.setReturnValue(session, 1); 2217 session.getSessionFactory(); 2218 sessionControl.setReturnValue(sf, 1); 2219 session.createQuery("some query string"); 2220 sessionControl.setReturnValue(query, 1); 2221 query.setParameter(0, "myvalue"); 2222 queryControl.setReturnValue(query, 1); 2223 query.executeUpdate(); 2224 queryControl.setReturnValue(5, 1); 2225 session.flush(); 2226 sessionControl.setVoidCallable(1); 2227 session.close(); 2228 sessionControl.setReturnValue(null, 1); 2229 sfControl.replay(); 2230 sessionControl.replay(); 2231 queryControl.replay(); 2232 2233 HibernateTemplate ht = new HibernateTemplate(sf); 2234 int result = ht.bulkUpdate("some query string", "myvalue"); 2235 assertTrue("Correct list", result == 5); 2236 queryControl.verify(); 2237 } 2238 testBulkUpdateWithParameters()2239 public void testBulkUpdateWithParameters() throws HibernateException { 2240 MockControl queryControl = MockControl.createControl(Query.class); 2241 Query query = (Query) queryControl.getMock(); 2242 2243 sf.openSession(); 2244 sfControl.setReturnValue(session, 1); 2245 session.getSessionFactory(); 2246 sessionControl.setReturnValue(sf, 1); 2247 session.createQuery("some query string"); 2248 sessionControl.setReturnValue(query, 1); 2249 query.setParameter(0, "myvalue1"); 2250 queryControl.setReturnValue(query, 1); 2251 query.setParameter(1, new Integer(2)); 2252 queryControl.setReturnValue(query, 1); 2253 query.executeUpdate(); 2254 queryControl.setReturnValue(5, 1); 2255 session.flush(); 2256 sessionControl.setVoidCallable(1); 2257 session.close(); 2258 sessionControl.setReturnValue(null, 1); 2259 sfControl.replay(); 2260 sessionControl.replay(); 2261 queryControl.replay(); 2262 2263 HibernateTemplate ht = new HibernateTemplate(sf); 2264 int result = ht.bulkUpdate("some query string", 2265 new Object[] {"myvalue1", new Integer(2)}); 2266 assertTrue("Correct list", result == 5); 2267 queryControl.verify(); 2268 } 2269 testExceptions()2270 public void testExceptions() throws HibernateException { 2271 SQLException sqlEx = new SQLException("argh", "27"); 2272 2273 final JDBCConnectionException jcex = new JDBCConnectionException("mymsg", sqlEx); 2274 try { 2275 createTemplate().execute(new HibernateCallback() { 2276 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2277 throw jcex; 2278 } 2279 }); 2280 fail("Should have thrown DataAccessResourceFailureException"); 2281 } 2282 catch (DataAccessResourceFailureException ex) { 2283 // expected 2284 assertEquals(jcex, ex.getCause()); 2285 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2286 } 2287 2288 final SQLGrammarException sgex = new SQLGrammarException("mymsg", sqlEx); 2289 try { 2290 createTemplate().execute(new HibernateCallback() { 2291 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2292 throw sgex; 2293 } 2294 }); 2295 fail("Should have thrown InvalidDataAccessResourceUsageException"); 2296 } 2297 catch (InvalidDataAccessResourceUsageException ex) { 2298 // expected 2299 assertEquals(sgex, ex.getCause()); 2300 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2301 } 2302 2303 final LockAcquisitionException laex = new LockAcquisitionException("mymsg", sqlEx); 2304 try { 2305 createTemplate().execute(new HibernateCallback() { 2306 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2307 throw laex; 2308 } 2309 }); 2310 fail("Should have thrown CannotAcquireLockException"); 2311 } 2312 catch (CannotAcquireLockException ex) { 2313 // expected 2314 assertEquals(laex, ex.getCause()); 2315 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2316 } 2317 2318 final ConstraintViolationException cvex = new ConstraintViolationException("mymsg", sqlEx, "myconstraint"); 2319 try { 2320 createTemplate().execute(new HibernateCallback() { 2321 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2322 throw cvex; 2323 } 2324 }); 2325 fail("Should have thrown DataIntegrityViolationException"); 2326 } 2327 catch (DataIntegrityViolationException ex) { 2328 // expected 2329 assertEquals(cvex, ex.getCause()); 2330 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2331 } 2332 2333 final DataException dex = new DataException("mymsg", sqlEx); 2334 try { 2335 createTemplate().execute(new HibernateCallback() { 2336 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2337 throw dex; 2338 } 2339 }); 2340 fail("Should have thrown DataIntegrityViolationException"); 2341 } 2342 catch (DataIntegrityViolationException ex) { 2343 // expected 2344 assertEquals(dex, ex.getCause()); 2345 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2346 } 2347 2348 final JDBCException jdex = new JDBCException("mymsg", sqlEx); 2349 try { 2350 createTemplate().execute(new HibernateCallback() { 2351 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2352 throw jdex; 2353 } 2354 }); 2355 fail("Should have thrown HibernateJdbcException"); 2356 } 2357 catch (HibernateJdbcException ex) { 2358 // expected 2359 assertEquals(jdex, ex.getCause()); 2360 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2361 } 2362 2363 final PropertyValueException pvex = new PropertyValueException("mymsg", "myentity", "myproperty"); 2364 try { 2365 createTemplate().execute(new HibernateCallback() { 2366 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2367 throw pvex; 2368 } 2369 }); 2370 fail("Should have thrown DataIntegrityViolationException"); 2371 } 2372 catch (DataIntegrityViolationException ex) { 2373 // expected 2374 assertEquals(pvex, ex.getCause()); 2375 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2376 } 2377 2378 try { 2379 createTemplate().execute(new HibernateCallback() { 2380 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2381 throw new PersistentObjectException(""); 2382 } 2383 }); 2384 fail("Should have thrown InvalidDataAccessApiUsageException"); 2385 } 2386 catch (InvalidDataAccessApiUsageException ex) { 2387 // expected 2388 } 2389 2390 try { 2391 createTemplate().execute(new HibernateCallback() { 2392 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2393 throw new TransientObjectException(""); 2394 } 2395 }); 2396 fail("Should have thrown InvalidDataAccessApiUsageException"); 2397 } 2398 catch (InvalidDataAccessApiUsageException ex) { 2399 // expected 2400 } 2401 2402 final ObjectDeletedException odex = new ObjectDeletedException("msg", "id", TestBean.class.getName()); 2403 try { 2404 createTemplate().execute(new HibernateCallback() { 2405 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2406 throw odex; 2407 } 2408 }); 2409 fail("Should have thrown InvalidDataAccessApiUsageException"); 2410 } 2411 catch (InvalidDataAccessApiUsageException ex) { 2412 // expected 2413 assertEquals(odex, ex.getCause()); 2414 } 2415 2416 final QueryException qex = new QueryException("msg"); 2417 qex.setQueryString("query"); 2418 try { 2419 createTemplate().execute(new HibernateCallback() { 2420 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2421 throw qex; 2422 } 2423 }); 2424 fail("Should have thrown InvalidDataAccessResourceUsageException"); 2425 } 2426 catch (HibernateQueryException ex) { 2427 // expected 2428 assertEquals(qex, ex.getCause()); 2429 assertEquals("query", ex.getQueryString()); 2430 } 2431 2432 final UnresolvableObjectException uoex = new UnresolvableObjectException("id", TestBean.class.getName()); 2433 try { 2434 createTemplate().execute(new HibernateCallback() { 2435 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2436 throw uoex; 2437 } 2438 }); 2439 fail("Should have thrown HibernateObjectRetrievalFailureException"); 2440 } 2441 catch (HibernateObjectRetrievalFailureException ex) { 2442 // expected 2443 assertEquals(TestBean.class.getName(), ex.getPersistentClassName()); 2444 assertEquals("id", ex.getIdentifier()); 2445 assertEquals(uoex, ex.getCause()); 2446 } 2447 2448 final ObjectNotFoundException onfe = new ObjectNotFoundException("id", TestBean.class.getName()); 2449 try { 2450 createTemplate().execute(new HibernateCallback() { 2451 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2452 throw onfe; 2453 } 2454 }); 2455 fail("Should have thrown HibernateObjectRetrievalFailureException"); 2456 } 2457 catch (HibernateObjectRetrievalFailureException ex) { 2458 // expected 2459 assertEquals(TestBean.class.getName(), ex.getPersistentClassName()); 2460 assertEquals("id", ex.getIdentifier()); 2461 assertEquals(onfe, ex.getCause()); 2462 } 2463 2464 final WrongClassException wcex = new WrongClassException("msg", "id", TestBean.class.getName()); 2465 try { 2466 createTemplate().execute(new HibernateCallback() { 2467 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2468 throw wcex; 2469 } 2470 }); 2471 fail("Should have thrown HibernateObjectRetrievalFailureException"); 2472 } 2473 catch (HibernateObjectRetrievalFailureException ex) { 2474 // expected 2475 assertEquals(TestBean.class.getName(), ex.getPersistentClassName()); 2476 assertEquals("id", ex.getIdentifier()); 2477 assertEquals(wcex, ex.getCause()); 2478 } 2479 2480 final NonUniqueResultException nuex = new NonUniqueResultException(2); 2481 try { 2482 createTemplate().execute(new HibernateCallback() { 2483 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2484 throw nuex; 2485 } 2486 }); 2487 fail("Should have thrown IncorrectResultSizeDataAccessException"); 2488 } 2489 catch (IncorrectResultSizeDataAccessException ex) { 2490 // expected 2491 assertEquals(1, ex.getExpectedSize()); 2492 assertEquals(-1, ex.getActualSize()); 2493 } 2494 2495 final StaleObjectStateException sosex = new StaleObjectStateException(TestBean.class.getName(), "id"); 2496 try { 2497 createTemplate().execute(new HibernateCallback() { 2498 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2499 throw sosex; 2500 } 2501 }); 2502 fail("Should have thrown HibernateOptimisticLockingFailureException"); 2503 } 2504 catch (HibernateOptimisticLockingFailureException ex) { 2505 // expected 2506 assertEquals(TestBean.class.getName(), ex.getPersistentClassName()); 2507 assertEquals("id", ex.getIdentifier()); 2508 assertEquals(sosex, ex.getCause()); 2509 } 2510 2511 final StaleStateException ssex = new StaleStateException("msg"); 2512 try { 2513 createTemplate().execute(new HibernateCallback() { 2514 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2515 throw ssex; 2516 } 2517 }); 2518 fail("Should have thrown HibernateOptimisticLockingFailureException"); 2519 } 2520 catch (HibernateOptimisticLockingFailureException ex) { 2521 // expected 2522 assertNull(ex.getPersistentClassName()); 2523 assertNull(ex.getIdentifier()); 2524 assertEquals(ssex, ex.getCause()); 2525 } 2526 2527 final HibernateException hex = new HibernateException("msg"); 2528 try { 2529 createTemplate().execute(new HibernateCallback() { 2530 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2531 throw hex; 2532 } 2533 }); 2534 fail("Should have thrown HibernateSystemException"); 2535 } 2536 catch (HibernateSystemException ex) { 2537 // expected 2538 assertEquals(hex, ex.getCause()); 2539 } 2540 } 2541 testFallbackExceptionTranslation()2542 public void testFallbackExceptionTranslation() throws HibernateException { 2543 SQLException sqlEx = new SQLException("argh", "27"); 2544 2545 final GenericJDBCException gjex = new GenericJDBCException("mymsg", sqlEx); 2546 try { 2547 createTemplate().execute(new HibernateCallback() { 2548 public Object doInHibernate(org.hibernate.Session session) throws HibernateException { 2549 throw gjex; 2550 } 2551 }); 2552 fail("Should have thrown DataIntegrityViolationException"); 2553 } 2554 catch (DataIntegrityViolationException ex) { 2555 // expected 2556 assertEquals(sqlEx, ex.getCause()); 2557 assertTrue(ex.getMessage().indexOf("mymsg") != -1); 2558 } 2559 } 2560 createTemplate()2561 private HibernateTemplate createTemplate() throws HibernateException { 2562 sfControl.reset(); 2563 sessionControl.reset(); 2564 sf.openSession(); 2565 sfControl.setReturnValue(session); 2566 session.getSessionFactory(); 2567 sessionControl.setReturnValue(sf, 1); 2568 session.close(); 2569 sessionControl.setReturnValue(null, 1); 2570 sfControl.replay(); 2571 sessionControl.replay(); 2572 return new HibernateTemplate(sf); 2573 } 2574 tearDown()2575 protected void tearDown() { 2576 try { 2577 sfControl.verify(); 2578 sessionControl.verify(); 2579 } 2580 catch (IllegalStateException ex) { 2581 // ignore: test method didn't call replay 2582 } 2583 assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty()); 2584 assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); 2585 } 2586 2587 } 2588