summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authormmis <michael.morris@ericsson.com>2018-03-16 09:44:46 +0000
committermmis <michael.morris@ericsson.com>2018-03-16 10:13:43 +0000
commitbcd810498395759aa3519b8a4e021c049918b2dc (patch)
tree6e7e4e72f8374423dffda0ac0edb76e6bfd7d531
parenta467c9229c8294d74b33ddb5a413d0515f8b714b (diff)
Removed checkstyle warnings
Removed checkstyle warnings in policy/common/utils Issue-ID: POLICY-695 Change-Id: I831b74c889d44784d6328619d88eb92fb524ce74 Signed-off-by: mmis <michael.morris@ericsson.com>
-rw-r--r--utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java58
-rw-r--r--utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java58
-rw-r--r--utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java83
-rw-r--r--utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java152
-rw-r--r--utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java152
-rw-r--r--utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java389
6 files changed, 444 insertions, 448 deletions
diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java
index 2ed54196..3532002e 100644
--- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java
+++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java
@@ -23,37 +23,37 @@ package org.onap.policy.common.utils.jpa;
import javax.persistence.EntityManager;
/**
- * Wrapper for an <i>EntityManager</i>, providing auto-close functionality. This
- * is useful in try-with-resources statements.
+ * Wrapper for an <i>EntityManager</i>, providing auto-close functionality. This is useful in
+ * try-with-resources statements.
*/
public class EntityMgrCloser implements AutoCloseable {
- /**
- * The wrapped manager.
- */
- private final EntityManager em;
-
- /**
- *
- * @param em
- * manager to be auto-closed
- */
- public EntityMgrCloser(EntityManager em) {
- this.em = em;
- }
-
- /**
- * Gets the EntityManager wrapped within this object.
- *
- * @return the associated EntityManager
- */
- public EntityManager getManager() {
- return em;
- }
-
- @Override
- public void close() {
- em.close();
- }
+ /**
+ * The wrapped manager.
+ */
+ private final EntityManager em;
+
+ /**
+ * Construct an instance with the EntityManager.
+ *
+ * @param em manager to be auto-closed
+ */
+ public EntityMgrCloser(EntityManager em) {
+ this.em = em;
+ }
+
+ /**
+ * Gets the EntityManager wrapped within this object.
+ *
+ * @return the associated EntityManager
+ */
+ public EntityManager getManager() {
+ return em;
+ }
+
+ @Override
+ public void close() {
+ em.close();
+ }
}
diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java
index 8910c087..b046cc55 100644
--- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java
+++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java
@@ -23,37 +23,37 @@ package org.onap.policy.common.utils.jpa;
import javax.persistence.EntityManagerFactory;
/**
- * Wrapper for an <i>EntityManagerFactory</i>, providing auto-close
- * functionality. This is useful in try-with-resources statements.
+ * Wrapper for an <i>EntityManagerFactory</i>, providing auto-close functionality. This is useful in
+ * try-with-resources statements.
*/
public class EntityMgrFactoryCloser implements AutoCloseable {
- /**
- * The wrapped factory.
- */
- private final EntityManagerFactory emf;
-
- /**
- *
- * @param emf
- * manager to be auto-closed
- */
- public EntityMgrFactoryCloser(EntityManagerFactory emf) {
- this.emf = emf;
- }
-
- /**
- * Gets the EntityManagerFactory wrapped within this object.
- *
- * @return the associated EntityManagerFactory
- */
- public EntityManagerFactory getFactory() {
- return emf;
- }
-
- @Override
- public void close() {
- emf.close();
- }
+ /**
+ * The wrapped factory.
+ */
+ private final EntityManagerFactory emf;
+
+ /**
+ * Construct an instance with the given EntityManagerFactory.
+ *
+ * @param emf manager to be auto-closed
+ */
+ public EntityMgrFactoryCloser(EntityManagerFactory emf) {
+ this.emf = emf;
+ }
+
+ /**
+ * Gets the EntityManagerFactory wrapped within this object.
+ *
+ * @return the associated EntityManagerFactory
+ */
+ public EntityManagerFactory getFactory() {
+ return emf;
+ }
+
+ @Override
+ public void close() {
+ emf.close();
+ }
}
diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java
index ce300741..3552a6fa 100644
--- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java
+++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java
@@ -23,55 +23,54 @@ package org.onap.policy.common.utils.jpa;
import javax.persistence.EntityTransaction;
/**
- * Wrapper for an <i>EntityTransaction</i> that is auto-rolled back when closed.
- * This is useful in try-with-resources statements.
+ * Wrapper for an <i>EntityTransaction</i> that is auto-rolled back when closed. This is useful in
+ * try-with-resources statements.
*/
public class EntityTransCloser implements AutoCloseable {
- /**
- * Transaction to be rolled back.
- */
- private final EntityTransaction trans;
+ /**
+ * Transaction to be rolled back.
+ */
+ private final EntityTransaction trans;
- /**
- * Begins a transaction.
- *
- * @param et
- * transaction to wrap/begin
- */
- public EntityTransCloser(EntityTransaction et) {
- trans = et;
- trans.begin();
- }
+ /**
+ * Begins a transaction.
+ *
+ * @param et transaction to wrap/begin
+ */
+ public EntityTransCloser(EntityTransaction et) {
+ trans = et;
+ trans.begin();
+ }
- /**
- * Gets the wrapped transaction.
- *
- * @return the transaction
- */
- public EntityTransaction getTransation() {
- return trans;
- }
+ /**
+ * Gets the wrapped transaction.
+ *
+ * @return the transaction
+ */
+ public EntityTransaction getTransation() {
+ return trans;
+ }
- /**
- * Commits the transaction.
- */
- public void commit() {
- trans.commit();
- }
+ /**
+ * Commits the transaction.
+ */
+ public void commit() {
+ trans.commit();
+ }
- /**
- * Rolls back the transaction.
- */
- public void rollback() {
- trans.rollback();
- }
+ /**
+ * Rolls back the transaction.
+ */
+ public void rollback() {
+ trans.rollback();
+ }
- @Override
- public void close() {
- if (trans.isActive()) {
- trans.rollback();
- }
- }
+ @Override
+ public void close() {
+ if (trans.isActive()) {
+ trans.rollback();
+ }
+ }
}
diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java
index abc8d93f..e791e084 100644
--- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java
+++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java
@@ -29,84 +29,82 @@ import javax.persistence.EntityManager;
import org.junit.Before;
import org.junit.Test;
-import org.onap.policy.common.utils.jpa.EntityMgrCloser;
public class EntityMgrCloserTest {
-
- private EntityManager mgr;
-
-
- @Before
- public void setUp() throws Exception {
- mgr = mock(EntityManager.class);
- }
-
-
- /**
- * Verifies that the constructor does not do anything extra before
- * being closed.
- */
- @Test
- public void testEntityMgrCloser() {
- EntityMgrCloser c = new EntityMgrCloser(mgr);
-
- assertEquals(mgr, c.getManager());
-
- // verify not closed yet
- verify(mgr, never()).close();
-
- c.close();
-
- verify(mgr).close();
- }
-
- @Test
- public void testGetManager() {
- try(EntityMgrCloser c = new EntityMgrCloser(mgr)) {
- assertEquals(mgr, c.getManager());
- }
- }
-
- /**
- * Verifies that the manager gets closed when close() is invoked.
- */
- @Test
- public void testClose() {
- EntityMgrCloser c = new EntityMgrCloser(mgr);
-
- c.close();
-
- // should be closed
- verify(mgr).close();
- }
-
- /**
- * Ensures that the manager gets closed when "try" block exits normally.
- */
- @Test
- public void testClose_TryWithoutExcept() {
- try(EntityMgrCloser c = new EntityMgrCloser(mgr)) {
-
- }
-
- verify(mgr).close();
- }
-
- /**
- * Ensures that the manager gets closed when "try" block throws an
- * exception.
- */
- @Test
- public void testClose_TryWithExcept() {
- try {
- try(EntityMgrCloser c = new EntityMgrCloser(mgr)) {
- throw new Exception("expected exception");
- }
-
- } catch (Exception e) {
- }
-
- verify(mgr).close();
- }
+
+ private EntityManager mgr;
+
+
+ @Before
+ public void setUp() throws Exception {
+ mgr = mock(EntityManager.class);
+ }
+
+
+ /**
+ * Verifies that the constructor does not do anything extra before being closed.
+ */
+ @Test
+ public void testEntityMgrCloser() {
+ EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr);
+
+ assertEquals(mgr, entityMgrCloser.getManager());
+
+ // verify not closed yet
+ verify(mgr, never()).close();
+
+ entityMgrCloser.close();
+
+ verify(mgr).close();
+ }
+
+ @Test
+ public void testGetManager() {
+ try (EntityMgrCloser c = new EntityMgrCloser(mgr)) {
+ assertEquals(mgr, c.getManager());
+ }
+ }
+
+ /**
+ * Verifies that the manager gets closed when close() is invoked.
+ */
+ @Test
+ public void testClose() {
+ EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr);
+
+ entityMgrCloser.close();
+
+ // should be closed
+ verify(mgr).close();
+ }
+
+ /**
+ * Ensures that the manager gets closed when "try" block exits normally.
+ */
+ @Test
+ public void testClose_TryWithoutExcept() {
+ try (EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr)) {
+ // No need to do anything in the try block
+ }
+
+ verify(mgr).close();
+ }
+
+ /**
+ * Ensures that the manager gets closed when "try" block throws an exception.
+ */
+ @Test
+ public void testClose_TryWithExcept() {
+ try {
+ try (EntityMgrCloser c = new EntityMgrCloser(mgr)) {
+ throw new Exception("expected exception");
+ }
+
+ } catch (Exception exception) {
+ // Ignore the exception
+ }
+
+ verify(mgr).close();
+ }
}
diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java
index 60ed27d0..8f2c0159 100644
--- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java
+++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java
@@ -29,84 +29,82 @@ import javax.persistence.EntityManagerFactory;
import org.junit.Before;
import org.junit.Test;
-import org.onap.policy.common.utils.jpa.EntityMgrFactoryCloser;
public class EntityMgrFactoryCloserTest {
-
- private EntityManagerFactory factory;
-
-
- @Before
- public void setUp() throws Exception {
- factory = mock(EntityManagerFactory.class);
- }
-
-
- /**
- * Verifies that the constructor does not do anything extra before
- * being closed.
- */
- @Test
- public void testEntityMgrFactoryCloser() {
- EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory);
-
- assertEquals(factory, c.getFactory());
-
- // verify not closed yet
- verify(factory, never()).close();
-
- c.close();
-
- verify(factory).close();
- }
-
- @Test
- public void testgetFactory() {
- try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
- assertEquals(factory, c.getFactory());
- }
- }
-
- /**
- * Verifies that the manager gets closed when close() is invoked.
- */
- @Test
- public void testClose() {
- EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory);
-
- c.close();
-
- // should be closed
- verify(factory).close();
- }
-
- /**
- * Ensures that the manager gets closed when "try" block exits normally.
- */
- @Test
- public void testClose_TryWithoutExcept() {
- try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
-
- }
-
- verify(factory).close();
- }
-
- /**
- * Ensures that the manager gets closed when "try" block throws an
- * exception.
- */
- @Test
- public void testClose_TryWithExcept() {
- try {
- try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
- throw new Exception("expected exception");
- }
-
- } catch (Exception e) {
- }
-
- verify(factory).close();
- }
+
+ private EntityManagerFactory factory;
+
+
+ @Before
+ public void setUp() throws Exception {
+ factory = mock(EntityManagerFactory.class);
+ }
+
+
+ /**
+ * Verifies that the constructor does not do anything extra before being closed.
+ */
+ @Test
+ public void testEntityMgrFactoryCloser() {
+ EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory);
+
+ assertEquals(factory, entityMgrFactoryCloser.getFactory());
+
+ // verify not closed yet
+ verify(factory, never()).close();
+
+ entityMgrFactoryCloser.close();
+
+ verify(factory).close();
+ }
+
+ @Test
+ public void testgetFactory() {
+ try (EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
+ assertEquals(factory, c.getFactory());
+ }
+ }
+
+ /**
+ * Verifies that the manager gets closed when close() is invoked.
+ */
+ @Test
+ public void testClose() {
+ EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory);
+
+ entityMgrFactoryCloser.close();
+
+ // should be closed
+ verify(factory).close();
+ }
+
+ /**
+ * Ensures that the manager gets closed when "try" block exits normally.
+ */
+ @Test
+ public void testClose_TryWithoutExcept() {
+ try (EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory)) {
+ // No need to do anything in the try block
+ }
+
+ verify(factory).close();
+ }
+
+ /**
+ * Ensures that the manager gets closed when "try" block throws an exception.
+ */
+ @Test
+ public void testClose_TryWithExcept() {
+ try {
+ try (EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
+ throw new Exception("expected exception");
+ }
+
+ } catch (Exception exception) {
+ // Ignore the exception
+ }
+
+ verify(factory).close();
+ }
}
diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java
index e7dcf11c..9a499e49 100644
--- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java
+++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java
@@ -31,201 +31,202 @@ import javax.persistence.EntityTransaction;
import org.junit.Before;
import org.junit.Test;
-import org.onap.policy.common.utils.jpa.EntityTransCloser;
public class EntityTransCloserTest {
-
- private EntityTransaction trans;
-
- @Before
- public void setUp() throws Exception {
- trans = mock(EntityTransaction.class);
-
- when(trans.isActive()).thenReturn(true);
- }
-
-
-
- /**
- * Verifies that the constructor starts a transaction, but does not do
- * anything extra before being closed.
- */
- @Test
- public void testEntityTransCloser() {
- EntityTransCloser t = new EntityTransCloser(trans);
-
- assertEquals(trans, t.getTransation());
-
- // verify that transaction was started
- verify(trans).begin();
-
- // verify not closed, committed, or rolled back yet
- verify(trans, never()).commit();
- verify(trans, never()).rollback();
-
- t.close();
-
- verify(trans).rollback();
- }
-
- @Test
- public void testGetTransation() {
- try(EntityTransCloser t = new EntityTransCloser(trans)) {
- assertEquals(trans, t.getTransation());
- }
- }
-
- /**
- * Verifies that the transaction is rolled back and the manager is
- * closed when and a transaction is active.
- */
- @Test
- public void testClose_Active() {
- EntityTransCloser t = new EntityTransCloser(trans);
-
- when(trans.isActive()).thenReturn(true);
-
- t.close();
-
- // closed and rolled back, but not committed
- verify(trans, never()).commit();
- verify(trans).rollback();
- }
-
- /**
- * Verifies that the manager is closed, but that the transaction is
- * <i>not</i> rolled back and when and no transaction is active.
- */
- @Test
- public void testClose_Inactive() {
- EntityTransCloser t = new EntityTransCloser(trans);
-
- when(trans.isActive()).thenReturn(false);
-
- t.close();
-
- // closed, but not committed or rolled back
- verify(trans, never()).commit();
- verify(trans, never()).rollback();
- }
-
- /**
- * Verifies that the manager is closed and the transaction rolled back
- * when "try" block exits normally and a transaction is active.
- */
- @Test
- public void testClose_TryWithoutExcept_Active() {
- when(trans.isActive()).thenReturn(true);
-
- try(EntityTransCloser t = new EntityTransCloser(trans)) {
-
- }
-
- // closed and rolled back, but not committed
- verify(trans, never()).commit();
- verify(trans).rollback();
- }
-
- /**
- * Verifies that the manager is closed, but that the transaction is
- * <i>not</i> rolled back when "try" block exits normally and no
- * transaction is active.
- */
- @Test
- public void testClose_TryWithoutExcept_Inactive() {
- when(trans.isActive()).thenReturn(false);
-
- try(EntityTransCloser t = new EntityTransCloser(trans)) {
-
- }
-
- // closed, but not rolled back or committed
- verify(trans, never()).commit();
- verify(trans, never()).rollback();
- }
-
- /**
- * Verifies that the manager is closed and the transaction rolled back
- * when "try" block throws an exception and a transaction is active.
- */
- @Test
- public void testClose_TryWithExcept_Active() {
- when(trans.isActive()).thenReturn(true);
-
- try {
- try(EntityTransCloser t = new EntityTransCloser(trans)) {
- throw new Exception("expected exception");
- }
-
- } catch (Exception e) {
- }
-
- // closed and rolled back, but not committed
- verify(trans, never()).commit();
- verify(trans).rollback();
- }
-
- /**
- * Verifies that the manager is closed, but that the transaction is
- * <i>not</i> rolled back when "try" block throws an exception and no
- * transaction is active.
- */
- @Test
- public void testClose_TryWithExcept_Inactive() {
- when(trans.isActive()).thenReturn(false);
-
- try {
- try(EntityTransCloser t = new EntityTransCloser(trans)) {
- throw new Exception("expected exception");
- }
-
- } catch (Exception e) {
- }
-
- // closed, but not rolled back or committed
- verify(trans, never()).commit();
- verify(trans, never()).rollback();
- }
-
- /**
- * Verifies that commit() only commits, and that the subsequent close()
- * does not re-commit.
- */
- @Test
- public void testCommit() {
- EntityTransCloser t = new EntityTransCloser(trans);
-
- t.commit();
-
- // committed, but not closed or rolled back
- verify(trans).commit();
- verify(trans, never()).rollback();
-
- // closed, but not re-committed
- t.close();
-
- verify(trans, times(1)).commit();
- }
-
- /**
- * Verifies that rollback() only rolls back, and that the subsequent
- * close() does not re-roll back.
- */
- @Test
- public void testRollback() {
- EntityTransCloser t = new EntityTransCloser(trans);
-
- t.rollback();
-
- // rolled back, but not closed or committed
- verify(trans, never()).commit();
- verify(trans).rollback();
-
- // closed, but not re-rolled back
- when(trans.isActive()).thenReturn(false);
- t.close();
-
- verify(trans, times(1)).rollback();
- }
+
+ private EntityTransaction trans;
+
+ /**
+ * Set up EntityTransaction mock.
+ */
+ @Before
+ public void setUp() throws Exception {
+ trans = mock(EntityTransaction.class);
+
+ when(trans.isActive()).thenReturn(true);
+ }
+
+
+
+ /**
+ * Verifies that the constructor starts a transaction, but does not do anything extra before
+ * being closed.
+ */
+ @Test
+ public void testEntityTransCloser() {
+ EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+ assertEquals(trans, entityTransCloser.getTransation());
+
+ // verify that transaction was started
+ verify(trans).begin();
+
+ // verify not closed, committed, or rolled back yet
+ verify(trans, never()).commit();
+ verify(trans, never()).rollback();
+
+ entityTransCloser.close();
+
+ verify(trans).rollback();
+ }
+
+ @Test
+ public void testGetTransation() {
+ try (EntityTransCloser t = new EntityTransCloser(trans)) {
+ assertEquals(trans, t.getTransation());
+ }
+ }
+
+ /**
+ * Verifies that the transaction is rolled back and the manager is closed when and a transaction
+ * is active.
+ */
+ @Test
+ public void testClose_Active() {
+ EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+ when(trans.isActive()).thenReturn(true);
+
+ entityTransCloser.close();
+
+ // closed and rolled back, but not committed
+ verify(trans, never()).commit();
+ verify(trans).rollback();
+ }
+
+ /**
+ * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back and
+ * when and no transaction is active.
+ */
+ @Test
+ public void testClose_Inactive() {
+ EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+ when(trans.isActive()).thenReturn(false);
+
+ entityTransCloser.close();
+
+ // closed, but not committed or rolled back
+ verify(trans, never()).commit();
+ verify(trans, never()).rollback();
+ }
+
+ /**
+ * Verifies that the manager is closed and the transaction rolled back when "try" block exits
+ * normally and a transaction is active.
+ */
+ @Test
+ public void testClose_TryWithoutExcept_Active() {
+ when(trans.isActive()).thenReturn(true);
+
+ try (EntityTransCloser entityTransCloser = new EntityTransCloser(trans)) {
+ // No need to do anything in the try block
+ }
+
+ // closed and rolled back, but not committed
+ verify(trans, never()).commit();
+ verify(trans).rollback();
+ }
+
+ /**
+ * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back when
+ * "try" block exits normally and no transaction is active.
+ */
+ @Test
+ public void testClose_TryWithoutExcept_Inactive() {
+ when(trans.isActive()).thenReturn(false);
+
+ try (EntityTransCloser entityTransCloser = new EntityTransCloser(trans)) {
+ // No need to do anything in the try block
+ }
+
+ // closed, but not rolled back or committed
+ verify(trans, never()).commit();
+ verify(trans, never()).rollback();
+ }
+
+ /**
+ * Verifies that the manager is closed and the transaction rolled back when "try" block throws
+ * an exception and a transaction is active.
+ */
+ @Test
+ public void testClose_TryWithExcept_Active() {
+ when(trans.isActive()).thenReturn(true);
+
+ try {
+ try (EntityTransCloser t = new EntityTransCloser(trans)) {
+ throw new Exception("expected exception");
+ }
+
+ } catch (Exception e) {
+ // Ignore the exception
+ }
+
+ // closed and rolled back, but not committed
+ verify(trans, never()).commit();
+ verify(trans).rollback();
+ }
+
+ /**
+ * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back when
+ * "try" block throws an exception and no transaction is active.
+ */
+ @Test
+ public void testClose_TryWithExcept_Inactive() {
+ when(trans.isActive()).thenReturn(false);
+
+ try {
+ try (EntityTransCloser t = new EntityTransCloser(trans)) {
+ throw new Exception("expected exception");
+ }
+
+ } catch (Exception e) {
+ // Ignore the exception
+ }
+
+ // closed, but not rolled back or committed
+ verify(trans, never()).commit();
+ verify(trans, never()).rollback();
+ }
+
+ /**
+ * Verifies that commit() only commits, and that the subsequent close() does not re-commit.
+ */
+ @Test
+ public void testCommit() {
+ EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+ entityTransCloser.commit();
+
+ // committed, but not closed or rolled back
+ verify(trans).commit();
+ verify(trans, never()).rollback();
+
+ // closed, but not re-committed
+ entityTransCloser.close();
+
+ verify(trans, times(1)).commit();
+ }
+
+ /**
+ * Verifies that rollback() only rolls back, and that the subsequent close() does not re-roll
+ * back.
+ */
+ @Test
+ public void testRollback() {
+ EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+ entityTransCloser.rollback();
+
+ // rolled back, but not closed or committed
+ verify(trans, never()).commit();
+ verify(trans).rollback();
+
+ // closed, but not re-rolled back
+ when(trans.isActive()).thenReturn(false);
+ entityTransCloser.close();
+
+ verify(trans, times(1)).rollback();
+ }
}