Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

HHH-13326 : test cases 

(cherry picked from commit 705ecec94f)
This commit is contained in:
Gail Badner 2019-03-19 16:58:28 -07:00 committed by gbadner
parent d25d7dc34b
commit 8aa976ea2d
3 changed files with 620 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
hibernate-core/src/test/java/org/hibernate/test/exceptionhandling/BaseJpaOrNativeBootstrapFunctionalTestCase.java
View File

@ -19,6 +19,7 @@ import javax.persistence.ValidationMode;
import javax.persistence.spi.PersistenceUnitTransactionType; import javax.persistence.spi.PersistenceUnitTransactionType;
import org.hibernate.HibernateException; import org.hibernate.HibernateException;
import org.hibernate.Interceptor;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.boot.registry.BootstrapServiceRegistry; import org.hibernate.boot.registry.BootstrapServiceRegistry;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder; import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
@ -84,6 +85,11 @@ public abstract class BaseJpaOrNativeBootstrapFunctionalTestCase extends BaseUni
return session; return session;
} }
protected Session openSession(Interceptor interceptor) throws HibernateException {
session = sessionFactory().withOptions().interceptor( interceptor ).openSession();
return session;
}
protected EntityManager openEntityManager() throws HibernateException { protected EntityManager openEntityManager() throws HibernateException {
return openSession().unwrap( EntityManager.class ); return openSession().unwrap( EntityManager.class );
} }

256
hibernate-core/src/test/java/org/hibernate/test/interceptor/InterceptorNonNullTransactionTest.java Normal file
View File

@ -0,0 +1,256 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.test.interceptor;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.Arrays;
import java.util.Map;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import org.hibernate.EmptyInterceptor;
import org.hibernate.Session;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.resource.transaction.spi.TransactionStatus;
import org.hibernate.test.exceptionhandling.BaseJpaOrNativeBootstrapFunctionalTestCase;
import org.hibernate.testing.junit4.CustomParameterized;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(CustomParameterized.class)
public class InterceptorNonNullTransactionTest extends BaseJpaOrNativeBootstrapFunctionalTestCase {
public enum JpaComplianceTransactionSetting { DEFAULT, TRUE, FALSE }
public enum JtaAllowTransactionAccessSetting { DEFAULT, TRUE, FALSE; };
@Parameterized.Parameters(name = "Bootstrap={0}, JpaComplianceTransactionSetting={1}, JtaAllowTransactionAccessSetting={2}")
public static Iterable<Object[]> parameters() {
return Arrays.asList( new Object[][] {
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.DEFAULT, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.FALSE },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.FALSE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.DEFAULT, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.FALSE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.FALSE },
} );
}
private final JpaComplianceTransactionSetting jpaComplianceTransactionSetting;
private final JtaAllowTransactionAccessSetting jtaAllowTransactionAccessSetting;
public InterceptorNonNullTransactionTest(
BootstrapMethod bootstrapMethod,
JpaComplianceTransactionSetting jpaComplianceTransactionSetting,
JtaAllowTransactionAccessSetting jtaAllowTransactionAccessSetting) {
super( bootstrapMethod );
this.jpaComplianceTransactionSetting = jpaComplianceTransactionSetting;
this.jtaAllowTransactionAccessSetting = jtaAllowTransactionAccessSetting;
}
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] { SimpleEntity.class };
}
@Override
protected void configure(Map<Object, Object> properties) {
super.configure( properties );
switch ( jpaComplianceTransactionSetting ) {
case DEFAULT:
// Keep the default (false)
break;
case TRUE:
properties.put( AvailableSettings.JPA_TRANSACTION_COMPLIANCE, "true" );
break;
case FALSE:
properties.put( AvailableSettings.JPA_TRANSACTION_COMPLIANCE, "false" );
break;
}
switch ( jtaAllowTransactionAccessSetting ) {
case DEFAULT:
// Keep the default (true native bootstrap; false if jpa bootstrap)
break;
case TRUE:
properties.put( AvailableSettings.ALLOW_JTA_TRANSACTION_ACCESS, "true" );
break;
case FALSE:
properties.put( AvailableSettings.ALLOW_JTA_TRANSACTION_ACCESS, "false" );
break;
}
}
@Test
public void testHibernateTransactionApi() throws Exception {
final TransactionInterceptor interceptor = new TransactionInterceptor();
Session session = sessionFactory().withOptions().interceptor( interceptor ).openSession();
session.getTransaction().begin();
assertTrue( interceptor.afterTransactionBeginMethodCalled );
assertTrue( interceptor.afterTransactionBeginAssertionPassed );
assertFalse( interceptor.beforeTransactionCompletionMethodCalled );
assertNull( interceptor.beforeTransactionCompletionAssertionPassed );
assertFalse( interceptor.afterTransactionCompletionMethodCalled );
assertNull( interceptor.afterTransactionCompletionAssertionPassed );
SimpleEntity entity = new SimpleEntity( "Hello World" );
session.save( entity );
interceptor.reset();
session.getTransaction().commit();
assertFalse( interceptor.afterTransactionBeginMethodCalled );
assertNull( interceptor.afterTransactionBeginAssertionPassed );
assertTrue( interceptor.beforeTransactionCompletionMethodCalled );
assertTrue( interceptor.afterTransactionCompletionMethodCalled );
assertEquals( true, interceptor.beforeTransactionCompletionAssertionPassed );
assertEquals( true, interceptor.afterTransactionCompletionAssertionPassed );
session.close();
}
@Test
public void testJtaApiWithSharedTransactionCoordinator() throws Exception {
final TransactionInterceptor interceptor = new TransactionInterceptor();
Session originalSession = openSession( interceptor );
Session session = originalSession.sessionWithOptions().interceptor( interceptor ).connection().openSession();
interceptor.reset();
session.getTransaction().begin();
assertTrue( interceptor.afterTransactionBeginMethodCalled );
assertTrue( interceptor.afterTransactionBeginAssertionPassed );
assertFalse( interceptor.beforeTransactionCompletionMethodCalled );
assertNull( interceptor.beforeTransactionCompletionAssertionPassed );
assertFalse( interceptor.afterTransactionCompletionMethodCalled );
assertNull( interceptor.afterTransactionCompletionAssertionPassed );
SimpleEntity entity = new SimpleEntity( "Hello World" );
session.save( entity );
interceptor.reset();
session.getTransaction().commit();
assertFalse( interceptor.afterTransactionBeginMethodCalled );
assertNull( interceptor.afterTransactionBeginAssertionPassed );
assertTrue( interceptor.beforeTransactionCompletionMethodCalled );
assertTrue( interceptor.afterTransactionCompletionMethodCalled );
assertEquals( true, interceptor.beforeTransactionCompletionAssertionPassed );
assertEquals( true, interceptor.afterTransactionCompletionAssertionPassed );
session.close();
originalSession.close();
}
@Entity(name = "SimpleEntity")
public static class SimpleEntity {
@Id
@GeneratedValue
private Integer id;
private String name;
SimpleEntity() {
}
SimpleEntity(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
private class TransactionInterceptor extends EmptyInterceptor {
private boolean afterTransactionBeginMethodCalled;
private Boolean afterTransactionBeginAssertionPassed;
private boolean beforeTransactionCompletionMethodCalled;
private Boolean beforeTransactionCompletionAssertionPassed;
private boolean afterTransactionCompletionMethodCalled;
private Boolean afterTransactionCompletionAssertionPassed;
public void reset() {
afterTransactionBeginMethodCalled = false;
afterTransactionBeginAssertionPassed = null;
beforeTransactionCompletionMethodCalled = false;
beforeTransactionCompletionAssertionPassed = null;
afterTransactionCompletionMethodCalled = false;
afterTransactionCompletionAssertionPassed = null;
}
@Override
public void afterTransactionBegin(org.hibernate.Transaction tx) {
afterTransactionBeginMethodCalled = true;
if ( tx != null ) {
afterTransactionBeginAssertionPassed = false;
assertEquals( TransactionStatus.ACTIVE, tx.getStatus() );
afterTransactionBeginAssertionPassed = true;
}
}
@Override
public void beforeTransactionCompletion(org.hibernate.Transaction tx) {
beforeTransactionCompletionMethodCalled = true;
if ( tx != null ) {
beforeTransactionCompletionAssertionPassed = false;
assertEquals( TransactionStatus.ACTIVE, tx.getStatus() );
beforeTransactionCompletionAssertionPassed = true;
}
}
@Override
public void afterTransactionCompletion(org.hibernate.Transaction tx) {
afterTransactionCompletionMethodCalled = true;
if ( tx != null ) {
afterTransactionCompletionAssertionPassed = false;
assertEquals( TransactionStatus.COMMITTED, tx.getStatus() );
afterTransactionCompletionAssertionPassed = true;
}
}
};
}

358
hibernate-core/src/test/java/org/hibernate/test/tm/InterceptorTransactionTest.java Normal file
View File

@ -0,0 +1,358 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.test.tm;
import java.util.Arrays;
import java.util.Map;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.transaction.Status;
import org.hibernate.EmptyInterceptor;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.resource.transaction.spi.TransactionStatus;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.jta.TestingJtaBootstrap;
import org.hibernate.testing.jta.TestingJtaPlatformImpl;
import org.hibernate.testing.junit4.CustomParameterized;
import org.hibernate.test.exceptionhandling.BaseJpaOrNativeBootstrapFunctionalTestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@TestForIssue( jiraKey = "HHH-13326")
@RunWith(CustomParameterized.class)
public class InterceptorTransactionTest extends BaseJpaOrNativeBootstrapFunctionalTestCase {
public enum JpaComplianceTransactionSetting { DEFAULT, TRUE, FALSE }
public enum JtaAllowTransactionAccessSetting {
DEFAULT {
@Override
public boolean allowTransactionAccess(
SessionFactory sessionFactory,
JpaComplianceTransactionSetting jpaComplianceTransactionSetting) {
return !sessionFactory.getSessionFactoryOptions().isJpaBootstrap() ||
jpaComplianceTransactionSetting != JpaComplianceTransactionSetting.TRUE;
}
},
TRUE {
@Override
public boolean allowTransactionAccess(
SessionFactory sessionFactory,
JpaComplianceTransactionSetting jpaComplianceTransactionSetting) {
return true;
}
},
FALSE {
@Override
public boolean allowTransactionAccess(
SessionFactory sessionFactory,
JpaComplianceTransactionSetting jpaComplianceTransactionSetting) {
// setting is ignored if jpaComplianceTransactionSetting != JpaComplianceTransactionSetting.TRUE
return jpaComplianceTransactionSetting != JpaComplianceTransactionSetting.TRUE;
}
};
public abstract boolean allowTransactionAccess(
SessionFactory sessionFactory,
JpaComplianceTransactionSetting jpaComplianceTransactionSetting
);
};
@Parameterized.Parameters(name = "Bootstrap={0}, JpaComplianceTransactionSetting={1}, JtaAllowTransactionAccessSetting={2}")
public static Iterable<Object[]> parameters() {
return Arrays.asList( new Object[][] {
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.DEFAULT, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.FALSE },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.JPA, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.FALSE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.DEFAULT, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.TRUE, JtaAllowTransactionAccessSetting.FALSE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.DEFAULT },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.TRUE },
{ BootstrapMethod.NATIVE, JpaComplianceTransactionSetting.FALSE, JtaAllowTransactionAccessSetting.FALSE },
} );
}
private final JpaComplianceTransactionSetting jpaComplianceTransactionSetting;
private final JtaAllowTransactionAccessSetting jtaAllowTransactionAccessSetting;
public InterceptorTransactionTest(
BootstrapMethod bootstrapMethod,
JpaComplianceTransactionSetting jpaComplianceTransactionSetting,
JtaAllowTransactionAccessSetting jtaAllowTransactionAccessSetting) {
super( bootstrapMethod );
this.jpaComplianceTransactionSetting = jpaComplianceTransactionSetting;
this.jtaAllowTransactionAccessSetting = jtaAllowTransactionAccessSetting;
}
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[] { SimpleEntity.class };
}
protected void configure(Map<Object, Object> properties) {
super.configure( properties );
TestingJtaBootstrap.prepare( properties );
properties.put( AvailableSettings.TRANSACTION_COORDINATOR_STRATEGY, "jta" );
switch ( jpaComplianceTransactionSetting ) {
case DEFAULT:
// Keep the default (false)
break;
case TRUE:
properties.put( AvailableSettings.JPA_TRANSACTION_COMPLIANCE, "true" );
break;
case FALSE:
properties.put( AvailableSettings.JPA_TRANSACTION_COMPLIANCE, "false" );
break;
}
switch ( jtaAllowTransactionAccessSetting ) {
case DEFAULT:
// Keep the default (true native bootstrap; false if jpa bootstrap)
break;
case TRUE:
properties.put( AvailableSettings.ALLOW_JTA_TRANSACTION_ACCESS, "true" );
break;
case FALSE:
properties.put( AvailableSettings.ALLOW_JTA_TRANSACTION_ACCESS, "false" );
break;
}
}
@Test
public void testHibernateTransactionApi() throws Exception {
final TransactionInterceptor interceptor = new TransactionInterceptor();
Session session = sessionFactory().withOptions().interceptor( interceptor ).openSession();
try {
session.getTransaction().begin();
if ( !jtaAllowTransactionAccessSetting.allowTransactionAccess(
sessionFactory(),
jpaComplianceTransactionSetting
) ) {
fail( "IllegalStateException should have been thrown." );
}
}
catch (IllegalStateException ex) {
if ( TestingJtaPlatformImpl.INSTANCE.getTransactionManager().getStatus() == Status.STATUS_ACTIVE ) {
TestingJtaPlatformImpl.INSTANCE.getTransactionManager().setRollbackOnly();
}
session.close();
assertEquals( JpaComplianceTransactionSetting.TRUE, jpaComplianceTransactionSetting );
return; // EARLY RETURN
}
// Interceptor#afterTransactionBegin is never called when using JTA
assertFalse( interceptor.afterTransactionBeginMethodCalled );
assertNull( interceptor.afterTransactionBeginAssertionPassed );
assertNull( interceptor.beforeTransactionCompletionAssertionPassed );
assertNull( interceptor.afterTransactionCompletionAssertionPassed );
SimpleEntity entity = new SimpleEntity( "Hello World" );
session.save( entity );
interceptor.reset();
session.getTransaction().commit();
assertTrue( interceptor.beforeTransactionCompletionMethodCalled );
assertTrue( interceptor.afterTransactionCompletionMethodCalled );
assertEquals( true, interceptor.beforeTransactionCompletionAssertionPassed );
assertEquals( true, interceptor.afterTransactionCompletionAssertionPassed );
assertNull( interceptor.afterTransactionBeginAssertionPassed );
session.close();
}
@Test
public void testJtaApi() throws Exception {
final TransactionInterceptor interceptor = new TransactionInterceptor();
Session session = sessionFactory().withOptions().interceptor( interceptor ).openSession();
TestingJtaPlatformImpl.INSTANCE.getTransactionManager().begin();
// Interceptor#afterTransactionBegin is never called when using JTA
assertFalse( interceptor.afterTransactionBeginMethodCalled );
assertNull( interceptor.afterTransactionBeginAssertionPassed );
assertNull( interceptor.beforeTransactionCompletionAssertionPassed );
assertNull( interceptor.afterTransactionCompletionAssertionPassed );
SimpleEntity entity = new SimpleEntity( "Hello World" );
session.save( entity );
interceptor.reset();
TestingJtaPlatformImpl.INSTANCE.getTransactionManager().commit();
assertTrue( interceptor.beforeTransactionCompletionMethodCalled );
assertTrue( interceptor.afterTransactionCompletionMethodCalled );
if ( jtaAllowTransactionAccessSetting.allowTransactionAccess(
sessionFactory(),
jpaComplianceTransactionSetting
) ) {
assertEquals( true, interceptor.beforeTransactionCompletionAssertionPassed );
assertEquals( true, interceptor.afterTransactionCompletionAssertionPassed );
}
else {
assertEquals( null, interceptor.beforeTransactionCompletionAssertionPassed );
assertEquals( null, interceptor.afterTransactionCompletionAssertionPassed );
}
assertNull( interceptor.afterTransactionBeginAssertionPassed );
session.close();
}
@Test
public void testJtaApiWithSharedTransactionCoordinator() throws Exception {
final TransactionInterceptor interceptor = new TransactionInterceptor();
Session originalSession = openSession();
Session session = originalSession.sessionWithOptions().connection().interceptor( interceptor ).openSession();
TestingJtaPlatformImpl.INSTANCE.getTransactionManager().begin();
// Interceptor#afterTransactionBegin is never called when using JTA
assertFalse( interceptor.afterTransactionBeginMethodCalled );
assertNull( interceptor.afterTransactionBeginAssertionPassed );
assertNull( interceptor.beforeTransactionCompletionAssertionPassed );
assertNull( interceptor.afterTransactionCompletionAssertionPassed );
SimpleEntity entity = new SimpleEntity( "Hello World" );
session.save( entity );
interceptor.reset();
TestingJtaPlatformImpl.INSTANCE.getTransactionManager().commit();
assertTrue( interceptor.beforeTransactionCompletionMethodCalled );
assertTrue( interceptor.afterTransactionCompletionMethodCalled );
if ( jtaAllowTransactionAccessSetting.allowTransactionAccess(
sessionFactory(),
jpaComplianceTransactionSetting
) ) {
assertEquals( true, interceptor.beforeTransactionCompletionAssertionPassed );
assertEquals( true, interceptor.afterTransactionCompletionAssertionPassed );
}
else {
assertEquals( null, interceptor.beforeTransactionCompletionAssertionPassed );
assertEquals( null, interceptor.afterTransactionCompletionAssertionPassed );
}
assertNull( interceptor.afterTransactionBeginAssertionPassed );
session.close();
originalSession.close();
}
@Entity(name = "SimpleEntity")
public static class SimpleEntity {
@Id
@GeneratedValue
private Integer id;
private String name;
SimpleEntity() {
}
SimpleEntity(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
private class TransactionInterceptor extends EmptyInterceptor {
private boolean afterTransactionBeginMethodCalled;
private Boolean afterTransactionBeginAssertionPassed;
private boolean beforeTransactionCompletionMethodCalled;
private Boolean beforeTransactionCompletionAssertionPassed;
private boolean afterTransactionCompletionMethodCalled;
private Boolean afterTransactionCompletionAssertionPassed;
public void reset() {
afterTransactionBeginMethodCalled = false;
afterTransactionBeginAssertionPassed = null;
beforeTransactionCompletionMethodCalled = false;
beforeTransactionCompletionAssertionPassed = null;
afterTransactionCompletionMethodCalled = false;
afterTransactionCompletionAssertionPassed = null;
}
@Override
public void afterTransactionBegin(org.hibernate.Transaction tx) {
afterTransactionBeginMethodCalled = true;
if ( tx != null ) {
afterTransactionBeginAssertionPassed = false;
assertEquals( TransactionStatus.ACTIVE, tx.getStatus() );
afterTransactionBeginAssertionPassed = true;
}
}
@Override
public void beforeTransactionCompletion(org.hibernate.Transaction tx) {
beforeTransactionCompletionMethodCalled = true;
if ( tx != null ) {
beforeTransactionCompletionAssertionPassed = false;
assertEquals( TransactionStatus.ACTIVE, tx.getStatus() );
beforeTransactionCompletionAssertionPassed = true;
}
}
@Override
public void afterTransactionCompletion(org.hibernate.Transaction tx) {
afterTransactionCompletionMethodCalled = true;
if ( tx != null ) {
afterTransactionCompletionAssertionPassed = false;
assertEquals( TransactionStatus.COMMITTED, tx.getStatus() );
afterTransactionCompletionAssertionPassed = true;
}
}
};
}