diff options
Diffstat (limited to 'utils/src/test/java/org/onap')
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(); + } } |