Speed up integrity-audit tests

Added additional DbDAO constructors to facilitate JUnit testing.
Added DbDAO destroy() method to close the EntityManagerFactory.
Pulled out common code into IntegrityAuditTestBase and subclassed
the tests from there.
Added hooks to IntegrityAudit so that the AuditThread timers could
be set to smaller values so that all of the junit tests could be
run in much less time.
Added similar hooks to DbAudit.
Modified integrity-audit tests to use new utility classes to auto-close
JPA managers.
Modified integrity-audit tests to use new utility class to scan logger
items without the need to scan the actual log file.
Added code to new test superclass to truncate the four ONAP logs.
Modified hooks in IntegrityAuditEntity to adjust serialization
so that dates are not serialized/de-serialized when used in junit
tests.
Deleted TestingUtils.
Added a test for invalid nodeType property.
Fixed issue wherein AuditThread doesn't stop when interrupted.

Change-Id: I5101995b6b68655b2810777bc4d2ec80c7cbc363
Issue-ID: POLICY-582
Signed-off-by: Jim Hahn <jrh3@att.com>

1 files changed, 450 insertions, 0 deletions

diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/DbDAOTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbDAOTest.java
new file mode 100644
index 00000000..c4cba280
--- /dev/null
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbDAOTest.java
@@ -0,0 +1,450 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.common.ia;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/*
+ * All JUnits are designed to run in the local development environment
+ * where they have write privileges and can execute time-sensitive
+ * tasks.
+ */
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+import javax.persistence.PersistenceUnitUtil;
+import javax.persistence.Query;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.onap.policy.common.ia.jpa.IntegrityAuditEntity;
+import org.onap.policy.common.utils.jpa.EntityTransCloser;
+
+/*
+ * All JUnits are designed to run in the local development environment
+ * where they have write privileges and can execute time-sensitive
+ * tasks.
+ */
+public class DbDAOTest extends IntegrityAuditTestBase {
+	private static String resourceName = "pdp0";
+
+	private DbDAO d;
+
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + DbDAOTest.class.getSimpleName());
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() {
+		IntegrityAuditTestBase.tearDownAfterClass();
+	}
+
+	@Before
+	public void setUp() {
+		super.setUp();
+		d = null;
+	}
+
+	@After
+	public void tearDown() {
+		if(d != null) {
+			d.destroy();
+		}
+		
+		super.tearDown();
+	}
+
+	/* Tests registering a new IntegrityAuditEntity object in the DB */
+	@Test
+	public void testNewRegistration() throws Exception {
+		Properties properties = makeProperties();
+
+		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+			d = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+			// Find the proper entry in the database
+			Query iaequery = em
+					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+			iaequery.setParameter("rn", DbDAOTest.resourceName);
+			iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
+
+			@SuppressWarnings("rawtypes")
+			List iaeList = iaequery.getResultList();
+
+			// Assert that the IntegrityAuditEntity object was found
+			assertNotNull(iaeList);
+
+			// flush to the DB
+			em.flush();
+			et.commit();
+		}
+	}
+
+	/*
+	 * Tests updating an IntegrityAuditEntity if it has already been registered
+	 */
+	@Test
+	public void testUpdateRegistration() throws Exception {
+		Properties properties = makeProperties();
+
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+		// Change site_name in properties to test that an update was made to
+		// an existing entry in the table
+		properties.put(IntegrityAuditProperties.SITE_NAME, "SiteB");
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+			// Find the proper entry in the database
+			Query iaequery = em
+					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+			iaequery.setParameter("rn", DbDAOTest.resourceName);
+			iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
+
+			@SuppressWarnings("rawtypes")
+			List iaeList = iaequery.getResultList();
+			IntegrityAuditEntity iae = null;
+			if (!iaeList.isEmpty()) {
+				// ignores multiple results
+				iae = (IntegrityAuditEntity) iaeList.get(0);
+
+				em.refresh(iae);
+				em.persist(iae);
+
+				// flush to the DB
+				em.flush();
+
+				// commit transaction
+				et.commit();
+
+				// Assert that the site_name for the existing entry was updated
+				assertEquals("SiteB", iae.getSite());
+			}
+		}
+	}
+
+	/* Tests obtaining all Integrity Audit Entities from a table */
+	@Test
+	public void testGetIntegrityAuditEntities() throws Exception {
+		Properties properties = makeProperties();
+
+		// Add some entries to the DB
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+		properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_drools");
+		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+		List<IntegrityAuditEntity> entities;
+		// Obtain entries based on persistenceUnit and nodeType
+		entities = d.getIntegrityAuditEntities(A_SEQ_PU, "pdp_xacml");
+		assertEquals(2, entities.size());
+	}
+
+	/* Tests retrieving a DbDAO instance's IntegrityAuditEntity */
+	@Test
+	public void testGetMyIntegrityAuditEntity() throws Exception {
+		Properties properties = makeProperties();
+
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+		IntegrityAuditEntity iae = d.getMyIntegrityAuditEntity();
+		// assertEquals("integrityAuditPU", iae.getPersistenceUnit());
+		assertEquals(A_SEQ_PU, iae.getPersistenceUnit());
+	}
+
+	/* Tests obtaining an IntegrityAuditEntity by ID */
+	@Test
+	public void testGetIntegrityAuditEntity() throws Exception {
+		Properties properties = makeProperties();
+
+		// Obtain an entry from the database based on ID
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+		// Find the proper database entry
+		Query iaequery = em
+				.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+		iaequery.setParameter("rn", DbDAOTest.resourceName);
+		iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
+
+		@SuppressWarnings("rawtypes")
+		List iaeList = iaequery.getResultList();
+		IntegrityAuditEntity iae = null;
+		if (!iaeList.isEmpty()) {
+			// ignores multiple results
+			iae = (IntegrityAuditEntity) iaeList.get(0);
+
+			// refresh the object from DB in case cached data was returned
+			em.refresh(iae);
+
+			// Obtain ID for an IntegrityAuditEntity
+			PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+			Object iaeId = util.getIdentifier(iae);
+
+			// Obtain the same IntegrityAuditEntity based on ID
+			IntegrityAuditEntity iaeDuplicate = d.getIntegrityAuditEntity((long) iaeId);
+			Object duplicateId = util.getIdentifier(iaeDuplicate);
+
+			// Assert that the proper entry was retrieved based on ID
+			assertEquals((long) iaeId, (long) duplicateId);
+		}
+	}
+
+	/* Tests setting an IntegrityAuditEntity as the designated node */
+	@Test
+	public void testSetDesignated() throws Exception {
+		Properties properties = makeProperties();
+
+		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+			// Create an entry and set it's designated field to true
+			d = new DbDAO(resourceName, A_SEQ_PU, properties);
+			d.setDesignated(resourceName, A_SEQ_PU, true);
+
+			// Find the proper entry in the database
+			Query iaequery = em
+					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+			iaequery.setParameter("rn", resourceName);
+			iaequery.setParameter("pu", A_SEQ_PU);
+
+			@SuppressWarnings("rawtypes")
+			List iaeList = iaequery.getResultList();
+			IntegrityAuditEntity iae = null;
+
+			if (!iaeList.isEmpty()) {
+				// ignores multiple results
+				iae = (IntegrityAuditEntity) iaeList.get(0);
+				em.refresh(iae);
+
+				// Check if the node is designated
+				boolean result = iae.isDesignated();
+
+				// Assert that it is designated
+				assertTrue(result);
+			}
+
+			// flush to the DB
+			em.flush();
+
+			// close the transaction
+			et.commit();
+		}
+	}
+
+	/* Tests that the lastUpdated column in the database is updated properly */
+	@Test
+	public void testSetLastUpdated() throws Exception {
+		Properties properties = makeProperties();
+
+		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+			// Create an entry
+			d = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+			// Find the proper entry in the database
+			Query iaequery = em
+					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+			iaequery.setParameter("rn", resourceName);
+			iaequery.setParameter("pu", A_SEQ_PU);
+
+			@SuppressWarnings("rawtypes")
+			List iaeList = iaequery.getResultList();
+			IntegrityAuditEntity iae = null;
+
+			if (!iaeList.isEmpty()) {
+				// ignores multiple results
+				iae = (IntegrityAuditEntity) iaeList.get(0);
+				// refresh the object from DB in case cached data was returned
+				em.refresh(iae);
+
+				// Obtain old update value and set new update value
+				Date oldDate = iae.getLastUpdated();
+
+				// ensure dates are different by sleeping for a bit
+				Thread.sleep(1);
+
+				iae.setSite("SiteB");
+				iae.setLastUpdated(new Date());
+				Date newDate = iae.getLastUpdated();
+
+				em.persist(iae);
+				// flush to the DB
+				em.flush();
+				// close the transaction
+				et.commit();
+
+				// Assert that the old and new update times are different
+				assertNotEquals(oldDate, newDate);
+			}
+		}
+	}
+
+	/* Tests that all the entries from a class can be retrieved */
+	@Test
+	public void testGetAllMyEntriesString() throws Exception {
+		Properties properties = makeProperties();
+
+		// create entries for the IntegrityAuditEntity table
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+		// Obtain a hash with the persisted objects
+		Map<Object, Object> entries = d.getAllMyEntries("org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
+
+		// Assert there were 3 entries for that class
+		assertEquals(3, entries.size());
+	}
+
+	/*
+	 * Tests retrieving all entities in a Persistence Unit using the class name
+	 * and a hashset of IDs
+	 */
+	@Test
+	public void testGetAllMyEntriesStringHashSet() throws Exception {
+		Properties properties = makeProperties();
+
+		// create entries for the IntegrityAuditEntity table
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+		// Obtain all entity keys
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		CriteriaQuery<Object> cq = cb.createQuery();
+		Root<?> rootEntry = cq.from(Class.forName("org.onap.policy.common.ia.jpa.IntegrityAuditEntity"));
+		CriteriaQuery<Object> all = cq.select(rootEntry);
+		TypedQuery<Object> allQuery = em.createQuery(all);
+		List<Object> objectList = allQuery.getResultList();
+		HashSet<Object> resultSet = new HashSet<Object>();
+		PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+		for (Object o : objectList) {
+			Object key = util.getIdentifier(o);
+			resultSet.add(key);
+		}
+
+		// Obtain a hash with the persisted objects
+		Map<Object, Object> entries = d.getAllMyEntries("org.onap.policy.common.ia.jpa.IntegrityAuditEntity",
+				resultSet);
+
+		// Assert there were 3 entries for that class
+		assertEquals(3, entries.size());
+	}
+
+	/*
+	 * Tests retrieving all entities in a Persistence Unit using the persistence
+	 * unit, properties, and class name
+	 */
+	@Test
+	public void testGetAllEntriesStringPropertiesString() throws Exception {
+		Properties properties = makeProperties();
+
+		// create entries for the IntegrityAuditEntity table
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+		// Obtain a hash with the persisted objects
+		Map<Object, Object> entries = d.getAllEntries("integrityAuditPU", properties,
+				"org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
+
+		// Assert there were 3 entries for that class
+		assertEquals(3, entries.size());
+	}
+
+	/*
+	 * Tests retrieving all entities in a Persistence Unit using the persistence
+	 * unit, properties, class name, and a hashset of IDs
+	 */
+	@Test
+	public void testGetAllEntriesStringPropertiesStringHashSet() throws Exception {
+		Properties properties = makeProperties();
+
+		// create entries for the IntegrityAuditEntity table
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+		// Obtain all entity keys
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		CriteriaQuery<Object> cq = cb.createQuery();
+		Root<?> rootEntry = cq.from(Class.forName("org.onap.policy.common.ia.jpa.IntegrityAuditEntity"));
+		CriteriaQuery<Object> all = cq.select(rootEntry);
+		TypedQuery<Object> allQuery = em.createQuery(all);
+		List<Object> objectList = allQuery.getResultList();
+		HashSet<Object> resultSet = new HashSet<Object>();
+		PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+		for (Object o : objectList) {
+			Object key = util.getIdentifier(o);
+			resultSet.add(key);
+		}
+
+		// Obtain a hash with the persisted objects
+		Map<Object, Object> entries = d.getAllEntries("integrityAuditPU", properties,
+				"org.onap.policy.common.ia.jpa.IntegrityAuditEntity", resultSet);
+
+		// Assert there were 3 entries for that class
+		assertEquals(3, entries.size());
+	}
+
+	/*
+	 * Tests getting all the entries from a class based on persistenceUnit,
+	 * properties, and className
+	 */
+	@Test
+	public void testGetAllEntries() throws Exception {
+		Properties properties = makeProperties();
+
+		// create entries for the IntegrityAuditEntity table
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+		// Obtain a hash with the persisted objects
+		Map<Object, Object> entries = d.getAllEntries(A_SEQ_PU, properties,
+				"org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
+
+		// Assert there were 3 entries for that class
+		assertEquals(3, entries.size());
+	}
+
+	/* Tests obtaining all class names of persisted classes */
+	public void testGetPersistenceClassNames() throws Exception {
+		Properties properties = makeProperties();
+
+		d = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+		// Retrieve persistence class names
+		Set<String> result = d.getPersistenceClassNames();
+		assertEquals(1, result.size());
+	}
+}