aboutsummaryrefslogtreecommitdiffstats
path: root/utils/src/test
diff options
context:
space:
mode:
Diffstat (limited to 'utils/src/test')
-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
3 files changed, 345 insertions, 348 deletions
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();
+ }
}