diff options
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(); + } } |