1 files changed, 195 insertions, 194 deletions

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