summaryrefslogtreecommitdiffstats
path: root/integrity-audit/src/test/java
diff options
context:
space:
mode:
Diffstat (limited to 'integrity-audit/src/test/java')
-rw-r--r--integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/AuditPeriodTest.java475
-rw-r--r--integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditCompareEntriesTest.java615
-rw-r--r--integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditTest.java749
-rw-r--r--integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbDAOTest.java725
-rw-r--r--integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/IntegrityAuditDesignationTest.java1101
-rw-r--r--integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/IaTestEntity.java163
-rw-r--r--integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/PersonTest.java64
7 files changed, 3892 insertions, 0 deletions
diff --git a/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/AuditPeriodTest.java b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/AuditPeriodTest.java
new file mode 100644
index 00000000..649b71f2
--- /dev/null
+++ b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/AuditPeriodTest.java
@@ -0,0 +1,475 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.common.ia.test;
+
+
+import static org.junit.Assert.*;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Properties;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Persistence;
+
+//import org.apache.commons.logging.Log;
+//import org.apache.commons.logging.LogFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.openecomp.policy.common.ia.AuditThread;
+import org.openecomp.policy.common.ia.IntegrityAudit;
+import org.openecomp.policy.common.ia.IntegrityAuditProperties;
+import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
+import org.openecomp.policy.common.logging.flexlogger.Logger;
+
+public class AuditPeriodTest {
+
+ private static Logger logger = FlexLogger.getLogger(AuditPeriodTest.class);
+
+ private static final String AUDIT_PERIOD_TEST_LOG = "./testingLogs/common-modules/integrity-audit/debug.log";
+
+ private static String persistenceUnit;
+ private static Properties properties;
+ private static String resourceName;
+
+ @Before
+ public void setUp() throws Exception {
+
+
+ System.out.println("setUp: Clearing " + AUDIT_PERIOD_TEST_LOG);
+ FileOutputStream fstream = new FileOutputStream(AUDIT_PERIOD_TEST_LOG);
+ fstream.close();
+
+ logger.info("setUp: Entering");
+
+ IntegrityAudit.isUnitTesting = true;
+
+ properties = new Properties();
+ properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ persistenceUnit = "testPU";
+ resourceName = "pdp1";
+
+ //Clean up the DB
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+
+ EntityManager em = emf.createEntityManager();
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
+
+ // commit transaction
+ et.commit();
+ em.close();
+
+ logger.info("setUp: Exiting");
+
+ }
+
+
+ @After
+ public void tearDown() throws Exception {
+
+ logger.info("tearDown: Entering");
+
+ logger.info("tearDown: Exiting");
+
+ }
+
+ /*
+ * Verifies (via log parsing) that when a negative audit period is
+ * specified, the audit is suppressed.
+ */
+ @Ignore
+ @Test
+ public void testNegativeAuditPeriod() throws Exception {
+
+ logger.info("testNegativeAuditPeriod: Entering");
+
+ properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "-1");
+
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) audit to immediately terminate.
+ */
+ Thread.sleep(1000);
+
+ logger.info("testNegativeAuditPeriod: Stopping audit thread (should be a no-op!)");
+ integrityAudit.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(AUDIT_PERIOD_TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("-1"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Suppressing integrity audit, integrityAuditPeriodSeconds=")) {
+ startIndex = strLine.indexOf("integrityAuditPeriodSeconds=") + 28;
+
+ String integrityAuditPeriodSeconds = strLine.substring(startIndex);
+
+ delegates.add(integrityAuditPeriodSeconds);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testNegativeAuditPeriod: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue(expectedResult.equals(delegates));
+
+ logger.info("testNegativeAuditPeriod: Exiting");
+
+ }
+
+ /*
+ * Verifies (via log parsing) that when an audit period of zero is
+ * specified, the audit runs continuously, generating a number of
+ * sleep/wake sequences in a short period of time (e.g. 100ms).
+ */
+ @Ignore
+ @Test
+ public void testZeroAuditPeriod() throws Exception {
+
+ logger.info("testZeroAuditPeriod: Entering");
+
+ properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "0");
+
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName,
+ persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) audit to generate a bunch of sleep wake sequences.
+ *
+ * Note:
+ *
+ * (AuditThread.AUDIT_SIMULATION_SLEEP_INTERVAL *
+ * AuditThread.AUDIT_SIMULATION_ITERATIONS) is the time it takes for the
+ * audit simulation to run.
+ *
+ * (integrityAudit.getIntegrityAuditPeriodSeconds() should return a
+ * value of zero; i.e. audit should not sleep at all between iterations
+ *
+ * "100"ms is the time we allow the audit to cycle continuously
+ */
+ long sleepMillis = (AuditThread.AUDIT_SIMULATION_SLEEP_INTERVAL * AuditThread.AUDIT_SIMULATION_ITERATIONS)
+ + (integrityAudit.getIntegrityAuditPeriodSeconds() * 1000)
+ + 100;
+ logger.info("testZeroAuditPeriod: Sleeping " + sleepMillis + "ms before stopping auditThread");
+ Thread.sleep(sleepMillis);
+
+ logger.info("testZeroAuditPeriod: Stopping audit thread");
+ integrityAudit.stopAuditThread();
+
+ /*
+ * Before audit completion message upon awaking from sleep is upper case "Awaking". After audit
+ * completion, all awakings are lower case "awaking".
+ */
+ logger.info("testZeroAuditPeriod: Parsing " + AUDIT_PERIOD_TEST_LOG + " for 'awaking'");
+ FileInputStream fstream = new FileInputStream(AUDIT_PERIOD_TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine = "";
+ int awakings = 0;
+ int lines = 0;
+ while ((strLine = br.readLine()) != null) {
+ if (strLine.contains("Awaking from 0ms sleep")) {
+ fail("Audit appears not to have run!? Got '" + strLine + "'");
+ } else {
+ if (strLine.contains("awaking from 0ms sleep")) {
+ awakings++;
+ }
+ }
+ lines++;
+ }
+ logger.info("testZeroAuditPeriod: Done parsing "
+ + AUDIT_PERIOD_TEST_LOG + " for 'awaking'; lines parsed="
+ + lines + ", closing stream");
+ fstream.close();
+
+ /*
+ * We should get at least 10 sleep/wake sequences.
+ */
+ assertTrue("Only " + awakings + " awakings", awakings > 10);
+ assertTrue(integrityAudit.getIntegrityAuditPeriodSeconds() == 0);
+
+ logger.info("testZeroAuditPeriod: Exiting, awakings="
+ + awakings + ", integrityAuditPeriodSeconds="
+ + integrityAudit.getIntegrityAuditPeriodSeconds());
+
+ }
+
+ /*
+ * Verifies (via log parsing) that when an audit period of five minutes is
+ * specified, there is a five minute interval between the audits run
+ * on each of three different entities.
+ */
+ @Ignore
+ @Test
+ public void testFiveMinuteAuditPeriod() throws Exception {
+
+ logger.info("testFiveMinuteAuditPeriod: Entering");
+
+ properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "300");
+
+ /*
+ * Start audit for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName,
+ persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Start audit for pdp2.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "300");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+ integrityAudit2.startAuditThread();
+
+ /*
+ * Start audit for pdp3.
+ */
+ Properties properties3 = new Properties();
+ properties3.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties3.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties3.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties3.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties3.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties3.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties3.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "300");
+ String persistenceUnit3 = "testPU";
+ String resourceName3 = "pdp3";
+ IntegrityAudit integrityAudit3 = new IntegrityAudit(resourceName3, persistenceUnit3, properties3);
+ integrityAudit3.startAuditThread();
+
+
+ /*
+ * 1) All three audit run once. This should take approximately 105 seconds, as follows:
+ *
+ * T0: pdp1 runs audit (15 seconds), then sleeps for five minutes (300 seconds)
+ * pdp2 recognizes that pdp1 is stale (30 seconds) and runs its audit (15 seconds)
+ * pdp3 recognizes that pdp2 is stale (30 seconds) and runs its audit (15 seconds)
+ *
+ * 2) Five minutes after T0, at T1, pdp1 wakes up and the above sequence begins again,
+ * which should take another 115 seconds:
+ *
+ * T1: pdp1 runs audit (15 seconds), then sleeps for two minutes (300 seconds)
+ * pdp2 wakes up, resets auditCompleted and sleeps (5 seconds), recognizes that pdp1 is stale (30 seconds) and runs its audit (15 seconds)
+ * pdp3 wakes up, resets auditCompleted and sleeps (5 seconds), recognizes that pdp2 is stale (30 seconds) and runs its audit (15 seconds)
+ *
+ * So, the entire sequence should take 15 + 300 + 115 = 430 seconds
+ * Adding a fudge factor, we sleep for 450 seconds
+ */
+ Thread.sleep(450000);
+
+
+ logger.info("testFiveMinuteAuditPeriod: Stopping all three audit threads");
+ integrityAudit.stopAuditThread();
+
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+ integrityAudit3.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(AUDIT_PERIOD_TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1", "pdp2", "pdp3"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testFiveMinuteAuditPeriod: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 6);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+ assertTrue("delegate 3 is " + expectedResult.get(3), expectedResult.get(3).equals(delegates.get(3)));
+ assertTrue("delegate 4 is " + expectedResult.get(4), expectedResult.get(4).equals(delegates.get(4)));
+ assertTrue("delegate 5 is " + expectedResult.get(5), expectedResult.get(5).equals(delegates.get(5)));
+
+ logger.info("testFiveMinuteAuditPeriod: Exiting");
+ }
+
+ /*
+ * Verifies (via log parsing) that when an audit period of 20 seconds is
+ * specified, there is a 20 second interval between the audits run
+ * on each of three different entities.
+ */
+ @Ignore
+ @Test
+ public void testTwentySecondAuditPeriod() throws Exception {
+
+ logger.info("testTwentySecondAuditPeriod: Entering");
+
+ properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "20");
+
+ /*
+ * Start audit for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName,
+ persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Start audit for pdp2.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "20");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+ integrityAudit2.startAuditThread();
+
+ /*
+ * Start audit for pdp3.
+ */
+ Properties properties3 = new Properties();
+ properties3.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties3.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties3.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties3.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties3.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties3.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties3.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "20");
+ String persistenceUnit3 = "testPU";
+ String resourceName3 = "pdp3";
+ IntegrityAudit integrityAudit3 = new IntegrityAudit(resourceName3, persistenceUnit3, properties3);
+ integrityAudit3.startAuditThread();
+
+
+ /*
+ * 1) All three audit run once.
+ *
+ * pdp1 runs audit (15 seconds), then goes into 20 second sleep cycles
+ * pdp2 recognizes that pdp1 is stale (30 seconds), runs its audit (15 seconds), then goes into 20 second sleep cycles
+ * pdp3 recognizes that pdp2 is stale (30 seconds), runs its audit (15 seconds), then goes into 20 second sleep cycles
+ *
+ * 2) Eventually pdp2 gets stale, pdp1 recognizes this and cycle begins again.
+ *
+ * So, we allow 15 + (5 * 45) = 240 seconds plus a fudge factor.
+ *
+ */
+ Thread.sleep(250000);
+
+
+ logger.info("testTwentySecondAuditPeriod: Stopping all three audit threads");
+ integrityAudit.stopAuditThread();
+
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+ integrityAudit3.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(AUDIT_PERIOD_TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1", "pdp2", "pdp3"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testTwentySecondAuditPeriod: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 6);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+ assertTrue("delegate 3 is " + expectedResult.get(3), expectedResult.get(3).equals(delegates.get(3)));
+ assertTrue("delegate 4 is " + expectedResult.get(4), expectedResult.get(4).equals(delegates.get(4)));
+ assertTrue("delegate 5 is " + expectedResult.get(5), expectedResult.get(5).equals(delegates.get(5)));
+
+ logger.info("testTwentySecondAuditPeriod: Exiting");
+ }
+
+}
diff --git a/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditCompareEntriesTest.java b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditCompareEntriesTest.java
new file mode 100644
index 00000000..f109689d
--- /dev/null
+++ b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditCompareEntriesTest.java
@@ -0,0 +1,615 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.common.ia.test;
+
+import static org.junit.Assert.*;
+
+import java.io.FileOutputStream;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Properties;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Persistence;
+
+
+//import org.apache.commons.logging.Log;
+//import org.apache.commons.logging.LogFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.openecomp.policy.common.ia.DbAudit;
+import org.openecomp.policy.common.ia.DbDAO;
+import org.openecomp.policy.common.ia.IntegrityAudit;
+import org.openecomp.policy.common.ia.IntegrityAuditProperties;
+import org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity;
+import org.openecomp.policy.common.ia.test.jpa.IaTestEntity;
+import org.openecomp.policy.common.ia.test.jpa.PersonTest;
+import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
+import org.openecomp.policy.common.logging.flexlogger.Logger;
+
+public class DbAuditCompareEntriesTest {
+
+ private static Logger logger = FlexLogger.getLogger(DbAuditCompareEntriesTest.class);
+ private DbDAO dbDAO;
+ private static String persistenceUnit;
+ private static Properties properties;
+ private static String resourceName;
+ private String dbDriver;
+ private String dbUrl;
+ private String dbUser;
+ private String dbPwd;
+ private String siteName;
+ private String nodeType;
+ private static final String TEST_LOG = "./testingLogs/common-modules/integrity-audit/debug.log";
+
+ @Before
+ public void setUp() throws Exception {
+ System.out.println("setUp: Clearing IntegrityAudit.log");
+ //FileOutputStream fstream = new FileOutputStream("IntegrityAudit.log");
+ FileOutputStream fstream = new FileOutputStream(TEST_LOG);
+ fstream.close();
+
+ logger.info("setUp: Entering");
+
+ IntegrityAudit.isUnitTesting = true;
+
+ properties = new Properties();
+ properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ dbDriver = IntegrityAuditProperties.DEFAULT_DB_DRIVER;
+ dbUrl = IntegrityAuditProperties.DEFAULT_DB_URL;
+ dbUser = IntegrityAuditProperties.DEFAULT_DB_USER;
+ dbPwd = IntegrityAuditProperties.DEFAULT_DB_PWD;
+ siteName = "SiteA";
+ nodeType = "pdp_xacml";
+ persistenceUnit = "testPU";
+ resourceName = "pdp1";
+
+ logger.info("setUp: Exiting");
+ }
+
+ /*
+ * Clean up DB after each test.
+ */
+ @After
+ public void tearDown() throws Exception {
+ logger.info("tearDown: Entering");
+
+ logger.info("tearDown: Exiting");
+ }
+
+ /*
+ * Tests that a comparison between hashsets is successful if
+ * the entries match
+ */
+ @Ignore
+ @Test
+ public void testSuccessfulComparison() throws Exception {
+ logger.info("testSuccessfulComparison: Entering");
+
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbAudit dbAudit = new DbAudit(dbDAO);
+
+ String className = null;
+ //There is only one entry IntegrityAuditEntity, but we will check anyway
+ HashSet<String> classNameSet = dbDAO.getPersistenceClassNames();
+ for(String c : classNameSet){
+ if (c.equals("org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity")){
+ className = c;
+ }
+ }
+ String resourceName1 = resourceName;
+ String resourceName2 = resourceName;
+
+ IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+ IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+ Date date = new Date();
+
+ /*
+ * Two entries with the same field values
+ */
+ entry1.setDesignated(false);
+ entry1.setJdbcDriver(dbDriver);
+ entry1.setJdbcPassword(dbPwd);
+ entry1.setJdbcUrl(dbUrl);
+ entry1.setJdbcUser(dbUser);
+ entry1.setLastUpdated(date);
+ entry1.setNodeType(nodeType);
+ entry1.setPersistenceUnit(persistenceUnit);
+ entry1.setResourceName(resourceName1);
+ entry1.setSite(siteName);
+
+ entry2.setDesignated(false);
+ entry2.setJdbcDriver(dbDriver);
+ entry2.setJdbcPassword(dbPwd);
+ entry2.setJdbcUrl(dbUrl);
+ entry2.setJdbcUser(dbUser);
+ entry2.setLastUpdated(date);
+ entry2.setNodeType(nodeType);
+ entry2.setPersistenceUnit(persistenceUnit);
+ entry2.setResourceName(resourceName2);
+ entry2.setSite(siteName);
+
+ dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
+
+ HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+ HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+ myEntries.put("pdp1", entry1);
+ theirEntries.put("pdp1", entry2);
+
+ HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
+
+ /*
+ * Assert that there are no mismatches returned
+ */
+ assertTrue(result.isEmpty());
+
+ logger.info("testSuccessfulComparison: Exit");
+ }
+
+ /*
+ * Tests that an error is detected if an entry in one hashset doesn't
+ * match the other
+ */
+ @Ignore
+ @Test
+ public void testComparisonError() throws Exception {
+ logger.info("testComparisonError: Entering");
+
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbAudit dbAudit = new DbAudit(dbDAO);
+
+ String resourceName1 = resourceName;
+ String resourceName2 = resourceName;
+
+ IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+ IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+ Date date = new Date();
+
+ /*
+ * Create two entries with different designated values
+ */
+ entry1.setDesignated(false);
+ entry1.setJdbcDriver(dbDriver);
+ entry1.setJdbcPassword(dbPwd);
+ entry1.setJdbcUrl(dbUrl);
+ entry1.setJdbcUser(dbUser);
+ entry1.setLastUpdated(date);
+ entry1.setNodeType(nodeType);
+ entry1.setPersistenceUnit(persistenceUnit);
+ entry1.setResourceName(resourceName1);
+ entry1.setSite(siteName);
+
+ entry2.setDesignated(true);
+ entry2.setJdbcDriver(dbDriver);
+ entry2.setJdbcPassword(dbPwd);
+ entry2.setJdbcUrl(dbUrl);
+ entry2.setJdbcUser(dbUser);
+ entry2.setLastUpdated(date);
+ entry2.setNodeType(nodeType);
+ entry2.setPersistenceUnit(persistenceUnit);
+ entry2.setResourceName(resourceName2);
+ entry2.setSite(siteName);
+
+ HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+ HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+ myEntries.put("pdp1", entry1);
+ theirEntries.put("pdp1", entry2);
+
+ HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
+
+ /*
+ * Assert that there was one mismatch
+ */
+ assertEquals(1, result.size());
+
+ logger.info("testComparisonError: Exit");
+ }
+
+ /*
+ * Tests that a mismatch/miss entry is detected if there are missing entries in
+ * one or both of the hashsets
+ */
+ @Ignore
+ @Test
+ public void testCompareMissingEntries() throws Exception {
+ logger.info("testCompareMissingEntries: Entering");
+
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbAudit dbAudit = new DbAudit(dbDAO);
+
+ String resourceName1 = resourceName;
+ String resourceName2 = resourceName;
+
+ IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+ IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+ IntegrityAuditEntity entry3 = new IntegrityAuditEntity();
+ IntegrityAuditEntity entry4 = new IntegrityAuditEntity();
+
+ Date date = new Date();
+
+ /*
+ * 4 entries, one mismatch, two miss entries
+ */
+ entry1.setDesignated(false);
+ entry1.setJdbcDriver(dbDriver);
+ entry1.setJdbcPassword(dbPwd);
+ entry1.setJdbcUrl(dbUrl);
+ entry1.setJdbcUser(dbUser);
+ entry1.setLastUpdated(date);
+ entry1.setNodeType(nodeType);
+ entry1.setPersistenceUnit(persistenceUnit);
+ entry1.setResourceName(resourceName1);
+ entry1.setSite(siteName);
+
+ entry2.setDesignated(true);
+ entry2.setJdbcDriver(dbDriver);
+ entry2.setJdbcPassword(dbPwd);
+ entry2.setJdbcUrl(dbUrl);
+ entry2.setJdbcUser(dbUser);
+ entry2.setLastUpdated(date);
+ entry2.setNodeType(nodeType);
+ entry2.setPersistenceUnit(persistenceUnit);
+ entry2.setResourceName(resourceName2);
+ entry2.setSite(siteName);
+
+ entry3.setDesignated(false);
+ entry3.setJdbcDriver(dbDriver);
+ entry3.setJdbcPassword(dbPwd);
+ entry3.setJdbcUrl(dbUrl);
+ entry3.setJdbcUser(dbUser);
+ entry3.setLastUpdated(date);
+ entry3.setNodeType(nodeType);
+ entry3.setPersistenceUnit(persistenceUnit);
+ entry3.setResourceName(resourceName2);
+ entry3.setSite("SiteB");
+
+ entry4.setDesignated(false);
+ entry4.setJdbcDriver(dbDriver);
+ entry4.setJdbcPassword(dbPwd);
+ entry4.setJdbcUrl(dbUrl);
+ entry4.setJdbcUser(dbUser);
+ entry4.setLastUpdated(date);
+ entry4.setNodeType(nodeType);
+ entry4.setPersistenceUnit(persistenceUnit);
+ entry4.setResourceName(resourceName2);
+ entry4.setSite("SiteB");
+
+ HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+ HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+ myEntries.put("0", entry1);
+ myEntries.put("1", entry3);
+ theirEntries.put("0", entry2);
+ theirEntries.put("2", entry4);
+
+ HashSet<Object> mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+
+ /*
+ * Assert 3 mismatches/missing entries were found
+ */
+ assertEquals(3, mismatchResult.size());
+
+ logger.info("testCompareMissingEntries: Exit");
+ }
+
+ /*
+ * Tests that comparison algorithm works for each entity in the hashsets
+ */
+ @Ignore
+ @Test
+ public void testCompareAllHashEntities() throws Exception {
+ logger.info("testCompareAllHashEntities: Entering");
+
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbAudit dbAudit = new DbAudit(dbDAO);
+
+ @SuppressWarnings("unused")
+ String className = null;
+ HashSet<String> classNameSet = dbDAO.getPersistenceClassNames();
+ HashSet<Object> mismatchResult = new HashSet<Object>();
+ for(String c : classNameSet) {
+ className = c;
+ if (c.equals("org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity")){
+ String resourceName1 = resourceName;
+ String resourceName2 = resourceName;
+
+ IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+ IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+ Date date = new Date();
+
+ /*
+ * Two entries with the same field values
+ */
+ entry1.setDesignated(false);
+ entry1.setJdbcDriver(dbDriver);
+ entry1.setJdbcPassword(dbPwd);
+ entry1.setJdbcUrl(dbUrl);
+ entry1.setJdbcUser(dbUser);
+ entry1.setLastUpdated(date);
+ entry1.setNodeType(nodeType);
+ entry1.setPersistenceUnit(persistenceUnit);
+ entry1.setResourceName(resourceName1);
+ entry1.setSite(siteName);
+
+ entry2.setDesignated(false);
+ entry2.setJdbcDriver(dbDriver);
+ entry2.setJdbcPassword(dbPwd);
+ entry2.setJdbcUrl(dbUrl);
+ entry2.setJdbcUser(dbUser);
+ entry2.setLastUpdated(date);
+ entry2.setNodeType(nodeType);
+ entry2.setPersistenceUnit(persistenceUnit);
+ entry2.setResourceName(resourceName2);
+ entry2.setSite(siteName);
+
+ HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+ HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+ myEntries.put("pdp1", entry1);
+ theirEntries.put("pdp1", entry2);
+
+ mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+
+ /*
+ * Assert there was no mismatches
+ */
+ assertTrue(mismatchResult.isEmpty());
+ }
+ else if (c.equals("org.openecomp.policy.common.ia.test.jpa.IaTestEntity")) {
+ IaTestEntity iate = new IaTestEntity();
+ IaTestEntity iate2 = new IaTestEntity();
+ IaTestEntity iate3 = new IaTestEntity();
+ IaTestEntity iate4 = new IaTestEntity();
+
+ Date date = new Date();
+
+ /*
+ * Four entries, 2 mismatches
+ */
+ iate.setCreatedBy("Ford");
+ iate.setModifiedBy("Ford");
+ iate.setModifiedDate(date);
+
+ iate2.setCreatedBy("Ford");
+ iate2.setModifiedBy("Zaphod");
+ iate2.setModifiedDate(date);
+
+ iate3.setCreatedBy("Zaphod");
+ iate3.setModifiedBy("Ford");
+ iate3.setModifiedDate(date);
+
+ iate4.setCreatedBy("Ford");
+ iate4.setModifiedBy("Ford");
+ iate4.setModifiedDate(date);
+
+ HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+ HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+ myEntries.put("0", iate);
+ myEntries.put("1", iate2);
+ theirEntries.put("0", iate3);
+ theirEntries.put("1", iate4);
+
+ mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+
+ /*
+ * Assert that there is 2 mismatches
+ */
+ assertEquals(2, mismatchResult.size());
+ }
+ }
+
+ logger.info("testCompareAllHashEntities: Exit");
+ }
+
+ /*
+ * Tests that comparison algorithm works for each entity in the database
+ */
+ @Ignore
+ @Test
+ public void testCompareAllDbEntities() throws Exception {
+ logger.info("testCompareAllDbEntities: Entering");
+
+ logger.info("Setting up DB");
+
+ IntegrityAudit.isUnitTesting = true;
+
+ properties = new Properties();
+ properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/iaTest2");
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ dbDriver = IntegrityAuditProperties.DEFAULT_DB_DRIVER;
+ dbUrl = IntegrityAuditProperties.DEFAULT_DB_URL;
+ dbUser = IntegrityAuditProperties.DEFAULT_DB_USER;
+ dbPwd = IntegrityAuditProperties.DEFAULT_DB_PWD;
+ siteName = "SiteA";
+ nodeType = "pdp_xacml";
+ persistenceUnit = "testPU";
+ resourceName = "pdp1";
+
+ //Clean up the two DBs
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManagerFactory emf2 = Persistence.createEntityManagerFactory(persistenceUnit, properties2);
+
+ EntityManager em = emf.createEntityManager();
+ EntityManager em2 = emf2.createEntityManager();
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+ EntityTransaction et2 = em2.getTransaction();
+
+ /*
+ * Delete entries in first DB
+ */
+ et.begin();
+
+ // Clean the IntegrityAuditEntity table
+ em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
+
+ // commit transaction
+ et.commit();
+
+ et.begin();
+
+ // Clean the IaTestEntity table
+ em.createQuery("Delete from IaTestEntity").executeUpdate();
+
+ // commit transaction
+ et.commit();
+ em.close();
+
+ /*
+ * Delete entries in second DB
+ */
+ et2.begin();
+
+ // Clean the IntegrityAuditEntity table
+ em2.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
+
+ // commit transaction
+ et2.commit();
+
+ et2.begin();
+
+ // Clean the IaTestEntity table
+ em2.createQuery("Delete from IaTestEntity").executeUpdate();
+
+ // commit transaction
+ et2.commit();
+ em2.close();
+ logger.info("Exiting set up");
+
+ // Add entries into DB1
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO dbDAO2 = new DbDAO("pdp2", persistenceUnit, properties);
+ DbAudit dbAudit = new DbAudit(dbDAO);
+
+ // Add entries into DB2
+ DbDAO dbDAO3 = new DbDAO(resourceName, persistenceUnit, properties2);
+ DbDAO dbDAO4 = new DbDAO("pdp2", persistenceUnit, properties2);
+
+ // Pull all entries and compare
+ HashSet<String> classNameSet = dbDAO.getPersistenceClassNames();
+ HashMap<Object, Object> myEntries;
+ HashMap<Object, Object> theirEntries;
+ HashSet<Object> mismatchResult = new HashSet<Object>();
+ String className;
+ for(String c : classNameSet) {
+ className = c;
+ logger.info("classNameSet entry = " + c);
+ myEntries = dbDAO.getAllEntries(persistenceUnit, properties, className);
+ theirEntries = dbDAO3.getAllEntries(persistenceUnit, properties2, className);
+ mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+ if(className.contains("IntegrityAuditEntity")){
+ break;
+ }
+ }
+
+ // Assert that there is 2 mismatches between IntegrityAuditEntity tables
+ assertEquals(2, mismatchResult.size());
+
+ logger.info("testCompareAllDbEntities: Exit");
+ }
+
+ /*
+ * Tests that differences in embedded classes are still caught
+ */
+ @Ignore
+ @Test
+ public void testEmbeddedClass() throws Exception {
+ logger.info("testEmbeddedClasses: Entering");
+
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbAudit dbAudit = new DbAudit(dbDAO);
+
+ String className = null;
+ //There is only one entry IntegrityAuditEntity, but we will check anyway
+ HashSet<String> classNameSet = dbDAO.getPersistenceClassNames();
+ for(String c : classNameSet){
+ if (c.equals("org.openecomp.policy.common.ia.test.jpa.IaTestEntity")){
+ className = c;
+ }
+ }
+
+ IaTestEntity iate = new IaTestEntity();
+ IaTestEntity iate2 = new IaTestEntity();
+
+ Date date = new Date();
+
+ PersonTest person = new PersonTest("Ford", "Prefect", 21);
+ PersonTest person2 = new PersonTest("Zaphod", "Beeblebrox", 25);
+
+ /*
+ * Two entries, 1 mismatch
+ */
+ iate.setCreatedBy("Ford");
+ iate.setModifiedBy("Zaphod");
+ iate.setModifiedDate(date);
+ iate.setPersonTest(person);
+
+ iate2.setCreatedBy("Ford");
+ iate2.setModifiedBy("Zaphod");
+ iate2.setModifiedDate(date);
+ iate2.setPersonTest(person2);
+
+ dbAudit.writeAuditDebugLog(className, "resource1", "resource2", iate, iate2);
+
+ HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+ HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+ myEntries.put("0", iate);
+ theirEntries.put("0", iate2);
+
+ HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
+
+ /*
+ * Assert that there are no mismatches returned
+ */
+ assertTrue(!result.isEmpty());
+
+ logger.info("testEmbeddedClasses: Exit");
+ }
+}
diff --git a/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditTest.java b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditTest.java
new file mode 100644
index 00000000..a84281dd
--- /dev/null
+++ b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditTest.java
@@ -0,0 +1,749 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.common.ia.test;
+
+import static org.junit.Assert.*;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Properties;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Persistence;
+import javax.persistence.Query;
+
+
+//import org.apache.commons.logging.Log;
+//import org.apache.commons.logging.LogFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.openecomp.policy.common.ia.DbAudit;
+import org.openecomp.policy.common.ia.DbAuditException;
+import org.openecomp.policy.common.ia.DbDAO;
+import org.openecomp.policy.common.ia.DbDaoTransactionException;
+import org.openecomp.policy.common.ia.IntegrityAudit;
+import org.openecomp.policy.common.ia.IntegrityAuditProperties;
+import org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity;
+import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
+import org.openecomp.policy.common.logging.flexlogger.Logger;
+
+public class DbAuditTest {
+
+ private static Logger logger = FlexLogger.getLogger(DbAuditTest.class);
+
+ private DbDAO dbDAO;
+ private static String persistenceUnit;
+ private static Properties properties;
+ private static String resourceName;
+ private String dbDriver;
+ private String dbUrl;
+ private String dbUser;
+ private String dbPwd;
+ private String siteName;
+ private String nodeType;
+ private static final String TEST_LOG = "./testingLogs/common-modules/integrity-audit/debug.log";
+ private static final String ERROR_LOG = "./testingLogs/common-modules/integrity-audit/error.log";
+
+ public void cleanLog() throws Exception{
+
+ logger.debug("cleanLog: enter");
+ //FileOutputStream fstream = new FileOutputStream("IntegrityAudit.log");
+ FileOutputStream fstream = new FileOutputStream(TEST_LOG);
+ fstream.close();
+ fstream = new FileOutputStream(ERROR_LOG);
+ fstream.close();
+ logger.debug("cleanLog: exit");
+ }
+
+ public void cleanDb(String persistenceUnit, Properties properties){
+ logger.debug("cleanDb: enter");
+
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+
+ EntityManager em = emf.createEntityManager();
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ et.begin();
+
+ // Clean up the DB
+ em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
+
+ // commit transaction
+ et.commit();
+ em.close();
+ logger.debug("cleanDb: exit");
+ }
+
+
+ @Before
+ public void setUp() throws Exception {
+
+ logger.info("setUp: Entering");
+
+ IntegrityAudit.isUnitTesting = true;
+ IntegrityAuditEntity.isUnitTesting = true;
+
+ properties = new Properties();
+ properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ dbDriver = IntegrityAuditProperties.DEFAULT_DB_DRIVER;
+ dbUrl = IntegrityAuditProperties.DEFAULT_DB_URL;
+ dbUser = IntegrityAuditProperties.DEFAULT_DB_USER;
+ dbPwd = IntegrityAuditProperties.DEFAULT_DB_PWD;
+ siteName = "SiteA";
+ nodeType = "pdp_xacml";
+ persistenceUnit = "testPU";
+ resourceName = "pdp1";
+
+ logger.info("setUp: Exiting");
+
+ }
+
+ @After
+ public void tearDown() throws Exception {
+
+ logger.info("tearDown: Entering");
+
+ //cleanDb(persistenceUnit, properties);
+
+ logger.info("tearDown: Exiting");
+ }
+
+ @Ignore
+ @Test
+ public void runAllTests() throws Exception{
+ //The order is important - I haven't figured out why, but it is.
+ mismatchTest();
+ noEntitiesTest();
+ oneEntityTest();
+ }
+
+
+ /*
+ * Tests printing an error to the log in the event where
+ * there are no entities saved in the database
+ */
+ public void noEntitiesTest() throws Exception {
+ cleanLog();
+ cleanDb(persistenceUnit, properties);
+
+ logger.info("noEntitiesTest: Entering");
+
+ // Boolean to assert there are no entries found
+ Boolean noEntities = false;
+
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ dbDAO.deleteAllIntegrityAuditEntities();
+ try {
+ DbAudit dbAudit = new DbAudit(dbDAO);
+ dbAudit.dbAudit(resourceName, persistenceUnit, nodeType);
+ }
+ catch (DbAuditException e) {
+ noEntities = true;
+ }
+
+ dbDAO.deleteAllIntegrityAuditEntities();
+
+ logger.info("noEntitiesTest: No entities are persisted in the database");
+
+ // Assert there are no entities retrieved
+ assertTrue(noEntities);
+
+ logger.info("noEntitiesTest: Exit");
+ }
+
+ /*
+ * Tests the detection of only one entry in the database
+ */
+ public void oneEntityTest() throws Exception{
+ cleanLog();
+ cleanDb(persistenceUnit, properties);
+
+ logger.info("oneEntityTest: Entering");
+
+ // Add one entry in the database
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbAudit dbAudit = new DbAudit(dbDAO);
+ dbAudit.dbAudit(resourceName, persistenceUnit, nodeType);
+
+ List<IntegrityAuditEntity> iaeList = dbDAO.getIntegrityAuditEntities(persistenceUnit, nodeType);
+ logger.info("List size: " + iaeList.size());
+
+ //FileInputStream fstream = new FileInputStream("IntegrityAudit.log");
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ Boolean oneEntity = false;
+ while ((strLine = br.readLine()) != null) {
+ //parse strLine to obtain what you want
+
+ if (strLine.contains("DbAudit: Found only one IntegrityAuditEntity entry:")) {
+ oneEntity = true;
+ }
+
+ }
+ if(oneEntity){
+ logger.info("oneEntityTest: One entity is persisted in the database");
+ }else{
+ logger.info("oneEntityTest: No entities are persisted in the database");
+ }
+
+
+ // Assert there is only one entry
+ assertTrue(oneEntity);
+
+ br.close();
+
+ logger.info("oneEntityTest: Exit");
+ }
+
+ /*
+ * Tests reporting mismatches and misentries using the error log
+ */
+ @SuppressWarnings("unused")
+ public void mismatchTest() throws Exception{
+ cleanLog();
+ logger.info("mismatchTest: Entering");
+
+ // Properties for DB2
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/iaTest2");
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ //Clean the DBs before we begin
+ cleanDb(persistenceUnit, properties);
+ cleanDb(persistenceUnit, properties2);
+
+ // Entries in DB1
+ dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO dbDAO2 = new DbDAO("pdp2", persistenceUnit, properties);
+
+ /*
+ * dbDAO3 is a mismatch entry, dbDAO7 is a misentry
+ */
+ DbDAO dbDAO3 = new DbDAO("pdp3", persistenceUnit, properties);
+ DbDAO dbDAO7 = new DbDAO("pdp4", persistenceUnit, properties);
+ Date date = new Date();
+
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+
+ /*
+ * Update DB url's in DB1 to point to DB2
+ */
+ try{
+ EntityManager em = emf.createEntityManager();
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp2");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList = iaequery.getResultList();
+ IntegrityAuditEntity iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ 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);
+ logger.info("Resource: " + "pdp2" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add teh resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp2" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp2");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl("jdbc:h2:file:./sql/iaTest2");
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp1");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList2 = iaequery.getResultList();
+ iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ if(!iaeList2.isEmpty()){
+ //ignores multiple results
+ iae = (IntegrityAuditEntity) iaeList2.get(0);
+ // refresh the object from DB in case cached data was returned
+ em.refresh(iae);
+ logger.info("Resource: " + "pdp1" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add teh resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp1" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp1");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl("jdbc:h2:file:./sql/iaTest2");
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp3");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList3 = iaequery.getResultList();
+ iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ if(!iaeList3.isEmpty()){
+ //ignores multiple results
+ iae = (IntegrityAuditEntity) iaeList3.get(0);
+ // refresh the object from DB in case cached data was returned
+ em.refresh(iae);
+ logger.info("Resource: " + "pdp3" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add the resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp3" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp3");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl(dbUrl);
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp4");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList4 = iaequery.getResultList();
+ iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ if(!iaeList4.isEmpty()){
+ //ignores multiple results
+ iae = (IntegrityAuditEntity) iaeList4.get(0);
+ // refresh the object from DB in case cached data was returned
+ em.refresh(iae);
+ logger.info("Resource: " + "pdp4" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add the resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp4" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp4");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl("jdbc:h2:file:./sql/iaTest2");
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+
+ em.close();
+ }catch (Exception e){
+ String msg = "DbDAO: " + "register() " + "ecountered a problem in execution: ";
+ logger.error(msg + e);
+ throw new DbDaoTransactionException(e);
+ }
+
+ /*
+ * Identical entries in from DB1 in DB2 except for dbDAO6
+ */
+ emf = Persistence.createEntityManagerFactory(persistenceUnit, properties2);
+ DbDAO dbDAO4 = new DbDAO(resourceName, persistenceUnit, properties2);
+
+ DbDAO dbDAO5 = new DbDAO("pdp2", persistenceUnit, properties2);
+
+ /*
+ * This is the mismatch entry
+ */
+ DbDAO dbDAO6 = new DbDAO("pdp3", persistenceUnit, properties2);
+ try{
+ EntityManager em = emf.createEntityManager();
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp2");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList = iaequery.getResultList();
+ IntegrityAuditEntity iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ 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);
+ logger.info("Resource: " + "pdp2" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add teh resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp2" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp2");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl("jdbc:h2:file:./sql/iaTest2");
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp1");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList2 = iaequery.getResultList();
+ iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ if(!iaeList2.isEmpty()){
+ //ignores multiple results
+ iae = (IntegrityAuditEntity) iaeList2.get(0);
+ // refresh the object from DB in case cached data was returned
+ em.refresh(iae);
+ logger.info("Resource: " + "pdp1" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add teh resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp1" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp1");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl("jdbc:h2:file:./sql/iaTest2");
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp3");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList3 = iaequery.getResultList();
+ iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ if(!iaeList3.isEmpty()){
+ //ignores multiple results
+ iae = (IntegrityAuditEntity) iaeList3.get(0);
+ // refresh the object from DB in case cached data was returned
+ em.refresh(iae);
+ logger.info("Resource: " + "pdp3" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add teh resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp3" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp3");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl("jdbc:h2:file:./sql/iaTest2");
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+
+ em.close();
+ }catch (Exception e){
+ String msg = "DbDAO: " + "register() " + "ecountered a problem in execution: ";
+ logger.error(msg + e);
+ throw new DbDaoTransactionException(e);
+
+ }
+
+ /*
+ * Run the DB Audit, once it finds a mismatch and sleeps, update DB1
+ * to have the same entry as DB2 it can be confirmed that the mismatch
+ * is resolved
+ */
+ DbAudit dbAudit = new DbAudit(dbDAO);
+ dbAudit.dbAudit(resourceName, persistenceUnit, nodeType);
+ emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ try{
+ EntityManager em = emf.createEntityManager();
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+ iaequery.setParameter("rn", "pdp3");
+ iaequery.setParameter("pu", persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList = iaequery.getResultList();
+ IntegrityAuditEntity iae = null;
+
+ //If it already exists, we just want to update the properties and lastUpdated date
+ 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);
+ logger.info("Resource: " + "pdp3" + " with PersistenceUnit: " + persistenceUnit
+ + " exists and entry be updated");
+ }else{
+ // If it does not exist, we also must add the resourceName, persistenceUnit and designated values
+ logger.info("Adding resource " + "pdp3" + " with PersistenceUnit: " + persistenceUnit
+ + " to IntegrityAuditEntity table");
+ iae = new IntegrityAuditEntity();
+ iae.setResourceName("pdp3");
+ iae.setPersistenceUnit(persistenceUnit);
+ iae.setDesignated(false);
+ }
+
+ //update/set properties in entry
+ iae.setSite(siteName);
+ iae.setNodeType(nodeType);
+ iae.setLastUpdated(date);
+ iae.setCreatedDate(date);
+ iae.setJdbcDriver(dbDriver);
+ iae.setJdbcPassword(dbPwd);
+ iae.setJdbcUrl("jdbc:h2:file:./sql/iaTest2");
+ iae.setJdbcUser(dbUser);
+
+ em.persist(iae);
+ // flush to the DB
+ em.flush();
+
+ // commit transaction
+ et.commit();
+ em.close();
+ }catch (Exception e){
+ String msg = "DbDAO: " + "register() " + "ecountered a problem in execution: ";
+ logger.error(msg + e);
+ throw new DbDaoTransactionException(e);
+ }
+
+ /*
+ * Run the audit again and correct the mismatch, the result should be one
+ * entry in the mismatchKeySet because of the misentry from the beginning
+ * of the test
+ */
+ dbAudit.dbAudit(resourceName, persistenceUnit, nodeType);
+
+ //Cleanup DB2
+ cleanDb(persistenceUnit, properties2);
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ String mismatchIndex = "";
+ while ((strLine = br.readLine()) != null) {
+ //parse strLine to obtain what you want...retrieve the last entry
+
+ if (strLine.contains("Mismatched entries (keys):")) {
+ startIndex = strLine.indexOf("(keys):") + 8;
+ mismatchIndex = strLine.substring(startIndex);
+ }
+ }
+ int mismatchEntries = mismatchIndex.trim().split(",").length;
+ logger.info("mismatchTest: mismatchIndex found: '" + mismatchIndex + "'"
+ + " mismatachEntries = " + mismatchEntries);
+
+ // Assert there is only one entry index
+ assertEquals(1, mismatchEntries);
+
+ br.close();
+
+ //Now check the entry in the error.log
+ fstream = new FileInputStream(ERROR_LOG);
+ br = new BufferedReader(new InputStreamReader(fstream));
+ String mismatchNum = "";
+ while ((strLine = br.readLine()) != null) {
+ //parse strLine to obtain what you want...retrieve the last entry
+
+ if (strLine.contains("DB Audit:")) {
+ startIndex = strLine.indexOf("DB Audit:") + 10;
+ mismatchNum = strLine.substring(startIndex, startIndex+1);
+ }
+ }
+ logger.info("mismatchTest: mismatchNum found: '" + mismatchNum + "'");
+
+ // Assert that there are a total of 3 mismatches - 1 between each comparison node.
+ assertEquals("3", mismatchNum);
+
+ br.close();
+
+ logger.info("mismatchTest: Exit");
+ }
+
+}
diff --git a/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbDAOTest.java b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbDAOTest.java
new file mode 100644
index 00000000..31fd0be6
--- /dev/null
+++ b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbDAOTest.java
@@ -0,0 +1,725 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.common.ia.test;
+
+import static org.junit.Assert.*;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Properties;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Persistence;
+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.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.openecomp.policy.common.ia.DbDAO;
+import org.openecomp.policy.common.ia.DbDaoTransactionException;
+import org.openecomp.policy.common.ia.IntegrityAuditProperties;
+import org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity;
+
+public class DbDAOTest {
+ private static String persistenceUnit;
+ private static Properties properties;
+ private static String resourceName;
+
+ DbDAO d;
+
+ @Before
+ public void setUp() throws Exception {
+ properties = new Properties();
+ properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ persistenceUnit = "integrityAuditPU";
+ resourceName = "pdp0";
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ }
+
+ /* Tests registering a new IntegrityAuditEntity object in the DB */
+ @Ignore
+ @Test
+ public void testNewRegistration() {
+ try {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin Transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ et.begin();
+ d = new DbDAO(resourceName, persistenceUnit, 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.persistenceUnit);
+
+ @SuppressWarnings("rawtypes")
+ List iaeList = iaequery.getResultList();
+
+ // Assert that the IntegrityAuditEntity object was found
+ assertNotNull(iaeList);
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+ em.close();
+
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests updating an IntegrityAuditEntity if it has already been registered */
+ @Ignore
+ @Test
+ public void testUpdateRegistration() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ // close the EntityManager
+ em.close();
+
+ try {
+ d = new DbDAO(resourceName, persistenceUnit, 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, persistenceUnit, properties);
+
+ em = emf.createEntityManager();
+
+ // Start a transaction
+ et = em.getTransaction();
+
+ // Begin Transaction
+ et.begin();
+
+ // 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.persistenceUnit);
+
+ @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();
+
+ // close the EntityManager
+ em.close();
+
+ // Assert that the site_name for the existing entry was updated
+ assertEquals("SiteB", iae.getSite());
+ }
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests obtaining all Integrity Audit Entities from a table */
+ @Ignore
+ @Test
+ public void testGetIntegrityAuditEntities() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+
+ // close the transaction
+ et.commit();
+
+ // close the EntityManager
+ em.close();
+
+ try {
+ // Add some entries to the DB
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO d2 = new DbDAO("pdp1", persistenceUnit, properties);
+ properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_drools");
+ DbDAO d3 = new DbDAO("pdp2", persistenceUnit, properties);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ List<IntegrityAuditEntity> entities;
+ try {
+ // Obtain entries based on persistenceUnit and nodeType
+ entities = d.getIntegrityAuditEntities(persistenceUnit, "pdp_xacml");
+ assertEquals(2, entities.size());
+ } catch (DbDaoTransactionException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests retrieving a DbDAO instance's IntegrityAuditEntity */
+ @Ignore
+ @Test
+ public void testGetMyIntegrityAuditEntity() {
+ try {
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ IntegrityAuditEntity iae = d.getMyIntegrityAuditEntity();
+ assertEquals("integrityAuditPU", iae.getPersistenceUnit());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests obtaining an IntegrityAuditEntity by ID */
+ @Ignore
+ @Test
+ public void testGetIntegrityAuditEntity() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+
+ // close the transaction
+ et.commit();
+
+ try {
+ // Obtain an entry from the database based on ID
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+
+ et.begin();
+
+ // 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.persistenceUnit);
+
+ @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);
+ }
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ // close the EntityManager
+ em.close();
+ }
+
+ /* Tests setting an IntegrityAuditEntity as the designated node */
+ @Ignore
+ @Test
+ public void testSetDesignated() {
+ try {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ et.begin();
+
+ // Create an entry and set it's designated field to true
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ d.setDesignated(resourceName, persistenceUnit, 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", persistenceUnit);
+
+ @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();
+
+ // close the EntityManager
+ em.close();
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests that the lastUpdated column in the database is updated properly */
+ @Ignore
+ @Test
+ public void testSetLastUpdated() {
+ try {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ et.begin();
+
+ // Create an entry
+ d = new DbDAO(resourceName, persistenceUnit, 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", persistenceUnit);
+
+ @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();
+ 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();
+ // close the EntityManager
+ em.close();
+
+ // Assert that the old and new update times are different
+ assertNotEquals(oldDate, newDate);
+ }
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests that all the entries from a class can be retrieved */
+ @Ignore
+ @Test
+ public void testGetAllMyEntriesString() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ // close the EntityManager
+ em.close();
+
+ try {
+ // create entries for the IntegrityAuditEntity table
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO d2 = new DbDAO("pdp1", persistenceUnit, properties);
+ DbDAO d3 = new DbDAO("pdp2", persistenceUnit, properties);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ try {
+ // Obtain a hash with the persisted objects
+ HashMap<Object, Object> entries = d.getAllMyEntries("org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity");
+
+ // Assert there were 3 entries for that class
+ assertEquals(3, entries.size());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests retrieving all entities in a Persistence Unit using the class name and a hashset of IDs */
+ @Ignore
+ @Test
+ public void testGetAllMyEntriesStringHashSet() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ try {
+ // create entries for the IntegrityAuditEntity table
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO d2 = new DbDAO("pdp1", persistenceUnit, properties);
+ DbDAO d3 = new DbDAO("pdp2", persistenceUnit, properties);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ try {
+ // Obtain all entity keys
+ CriteriaBuilder cb = em.getCriteriaBuilder();
+ CriteriaQuery<Object> cq = cb.createQuery();
+ Root<?> rootEntry = cq.from(Class.forName("org.openecomp.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
+ HashMap<Object, Object> entries = d.getAllMyEntries("org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity", resultSet);
+
+ // Assert there were 3 entries for that class
+ assertEquals(3, entries.size());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ // close the EntityManager
+ em.close();
+ }
+
+ /* Tests retrieving all entities in a Persistence Unit using the persistence unit, properties, and class name */
+ @Ignore
+ @Test
+ public void testGetAllEntriesStringPropertiesString() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ // close the EntityManager
+ em.close();
+
+ try {
+ // create entries for the IntegrityAuditEntity table
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO d2 = new DbDAO("pdp1", persistenceUnit, properties);
+ DbDAO d3 = new DbDAO("pdp2", persistenceUnit, properties);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ try {
+ // Obtain a hash with the persisted objects
+ HashMap<Object, Object> entries = d.getAllEntries("integrityAuditPU", properties, "org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity");
+
+ // Assert there were 3 entries for that class
+ assertEquals(3, entries.size());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests retrieving all entities in a Persistence Unit using the persistence unit, properties, class name, and a hashset of IDs */
+ @Ignore
+ @Test
+ public void testGetAllEntriesStringPropertiesStringHashSet() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ try {
+ // create entries for the IntegrityAuditEntity table
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO d2 = new DbDAO("pdp1", persistenceUnit, properties);
+ DbDAO d3 = new DbDAO("pdp2", persistenceUnit, properties);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ try {
+ // Obtain all entity keys
+ CriteriaBuilder cb = em.getCriteriaBuilder();
+ CriteriaQuery<Object> cq = cb.createQuery();
+ Root<?> rootEntry = cq.from(Class.forName("org.openecomp.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
+ HashMap<Object, Object> entries = d.getAllEntries("integrityAuditPU", properties, "org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity", resultSet);
+
+ // Assert there were 3 entries for that class
+ assertEquals(3, entries.size());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ // close the EntityManager
+ em.close();
+ }
+
+ /* Tests getting all the entries from a class based on persistenceUnit, properties, and className */
+ @Ignore
+ @Test
+ public void testGetAllEntries() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ // close the EntityManager
+ em.close();
+
+ try {
+ // create entries for the IntegrityAuditEntity table
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ DbDAO d2 = new DbDAO("pdp1", persistenceUnit, properties);
+ DbDAO d3 = new DbDAO("pdp2", persistenceUnit, properties);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ try {
+ // Obtain a hash with the persisted objects
+ HashMap<Object, Object> entries = d.getAllEntries(persistenceUnit, properties, "org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity");
+
+ // Assert there were 3 entries for that class
+ assertEquals(3, entries.size());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /* Tests obtaining all class names of persisted classes */
+ public void testGetPersistenceClassNames() {
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+ EntityManager em = emf.createEntityManager();
+
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ // Begin transaction
+ et.begin();
+
+ // Clean the DB
+ em.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
+
+ // flush to the DB
+ em.flush();
+ et.commit();
+
+ // close the EntityManager
+ em.close();
+
+ try {
+ d = new DbDAO(resourceName, persistenceUnit, properties);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ // Retrieve persistence class names
+ HashSet<String> result = d.getPersistenceClassNames();
+ assertEquals(1, result.size());
+ }
+}
diff --git a/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/IntegrityAuditDesignationTest.java b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/IntegrityAuditDesignationTest.java
new file mode 100644
index 00000000..6eb5fa4e
--- /dev/null
+++ b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/IntegrityAuditDesignationTest.java
@@ -0,0 +1,1101 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.common.ia.test;
+
+import static org.junit.Assert.*;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Properties;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Persistence;
+
+
+
+//import org.apache.commons.logging.Log;
+//import org.apache.commons.logging.LogFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.openecomp.policy.common.ia.AuditThread;
+import org.openecomp.policy.common.ia.DbDAO;
+import org.openecomp.policy.common.ia.IntegrityAudit;
+import org.openecomp.policy.common.ia.IntegrityAuditProperties;
+import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
+import org.openecomp.policy.common.logging.flexlogger.Logger;
+
+public class IntegrityAuditDesignationTest {
+
+ private static Logger logger = FlexLogger.getLogger(IntegrityAuditDesignationTest.class);
+
+ /*
+ * Provides a little cushion for timing events.
+ */
+ private static int FUDGE_FACTOR = 5000;
+
+ private static String persistenceUnit;
+ private static Properties properties;
+ private static String resourceName;
+ private static final String TEST_LOG = "./testingLogs/common-modules/integrity-audit/debug.log";
+ @Before
+ public void setUp() throws Exception {
+
+
+ System.out.println("setUp: Clearing debug.log");
+ FileOutputStream fstream = new FileOutputStream(TEST_LOG);
+ fstream.close();
+
+ logger.info("setUp: Entering");
+
+ IntegrityAudit.isUnitTesting = true;
+
+ properties = new Properties();
+ properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+
+ /*
+ * AuditThread.AUDIT_THREAD_SLEEP_INTERVAL is also five seconds, so
+ * setting AUDIT_PERIOD_SECONDS to 5 ensures that whether or not audit
+ * has already been run on a node, it will sleep the same amount of
+ * time.
+ */
+ properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+
+ persistenceUnit = "testPU";
+ resourceName = "pdp1";
+
+
+ //Clean up the DB
+ EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+
+ EntityManager em = emf.createEntityManager();
+ // Start a transaction
+ EntityTransaction et = em.getTransaction();
+
+ et.begin();
+
+ // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
+ em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
+
+ // commit transaction
+ et.commit();
+ em.close();
+ logger.info("setUp: Exiting");
+
+ }
+
+
+ @After
+ public void tearDown() throws Exception {
+
+ logger.info("tearDown: Entering");
+
+ logger.info("tearDown: Exiting");
+
+ }
+
+ /*
+ * Tests designation logic when only one functioning resource is in play. Designation
+ * should stay with single resource.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test was successful.
+ */
+ @Ignore
+ @Test
+ public void testOneResource() throws Exception {
+
+ logger.info("testOneResource: Entering");
+
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 to run audit (15 seconds)
+ *
+ * 2) Logic to detect that no other node is available for designation (60 seconds)
+ *
+ * 3) pdp1 to run audit again (15 seconds)
+ */
+ logger.info("testOneResource: Sleeping 100 seconds");
+ Thread.sleep(100000);
+
+ logger.info("testOneResource: Stopping audit thread");
+ integrityAudit.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+
+ String rName = "";
+ while ((strLine = br.readLine()) != null) {
+ // parse strLine to obtain what you want
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+ rName = strLine.substring(startIndex, endIndex);
+ logger.info("testOneResource: rName: " + rName);
+ assertEquals("pdp1", rName);
+ }
+ }
+ fstream.close();
+
+ /*
+ * Test fix for ECOMPD2TD-783: Audit fails to run when application is restarted.
+ */
+ integrityAudit.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 to run audit (15 seconds)
+ *
+ * 2) Logic to detect that no other node is available for designation (60 seconds)
+ *
+ * 3) pdp1 to run audit again (15 seconds)
+ */
+ logger.info("testOneResource: Sleeping 100 seconds for second time");
+ Thread.sleep(100000);
+
+ logger.info("testOneResource: Stopping audit thread for second time");
+ integrityAudit.stopAuditThread();
+
+ fstream = new FileInputStream(TEST_LOG);
+ br = new BufferedReader(new InputStreamReader(fstream));
+
+ rName = "";
+ while ((strLine = br.readLine()) != null) {
+ // parse strLine to obtain what you want
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+ rName = strLine.substring(startIndex, endIndex);
+ logger.info("testOneResource: rName: " + rName);
+ assertEquals("pdp1", rName);
+ }
+ }
+ fstream.close();
+
+ logger.info("testOneResource: Exiting");
+
+ }
+
+ /*
+ * Tests designation logic when two functioning resources are in play.
+ * Designation should alternate between resources.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test
+ * was successful. A quick way of examining the log is to search for the
+ * string "audit simulation":
+ *
+ * As you can see from the "dbAuditSimulate" method, when it executes, it
+ * logs the "Starting audit simulation..." message and when it finishes, it
+ * logs the "Finished audit simulation..." message. By looking for these
+ * messages, you can verify that the audits are run by the proper resource.
+ * For example, when testFourResourcesOneDead is run, you should see a
+ * Starting.../Finished... sequence for pdp1, followed by a
+ * Starting.../Finished... sequence for pdp2, followed by a
+ * Starting.../Finished... sequence for pdp4 (pdp3 is skipped as it's
+ * dead/hung), followed by a Starting.../Finished... sequence for pdp1, etc.
+ */
+ @Ignore
+ @Test
+ public void testTwoResources() throws Exception {
+
+ logger.info("testTwoResources: Entering");
+
+ /*
+ * Start audit for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Start audit for pdp2.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+ integrityAudit2.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 to run audit (15 seconds)
+ *
+ * 2) Logic to detect that pdp1 is stale and designate pdp2 (30 seconds)
+ *
+ * 3) pdp2 to run audit (15 seconds)
+ *
+ * 4) Logic to detect that pdp2 is stale and designate pdp1 (30 seconds)
+ *
+ * 5) pdp1 to run audit (15 seconds)
+ */
+ Thread.sleep(120000);
+
+ logger.info("testTwoResources: Stopping audit threads");
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp1"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testTwoResources: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue(expectedResult.equals(delegates));
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 3);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+
+ logger.info("testTwoResources: Exiting");
+
+ }
+
+ /*
+ * Tests designation logic when two functioning resources are in play, each
+ * with different PUs. Audits for "testPU" and "integrityAuditPU" should run
+ * simultaneously. Designation should not alternate.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test
+ * was successful.
+ */
+ @Ignore
+ @Test
+ public void testTwoResourcesDifferentPus() throws Exception {
+
+ logger.info("testTwoResourcesDifferentPus: Entering");
+
+ /*
+ * Start audit for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Start audit for pdp2.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "integrityAuditPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+ integrityAudit2.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 and pdp2 to run audit simultaneously (15 seconds)
+ *
+ * 2) Logic to detect that no other node is available for designation for either pdp1 or pdp2 (60 seconds)
+ *
+ * 3) pdp1 and pdp2 to again run audit simultaneously (15 seconds)
+ *
+ * NOTE: Based on the above, you would think a 100000ms sleep would be appropriate,
+ * but for some reason, when all tests are run this test errors.
+ */
+ logger.info("testTwoResourcesDifferentPus: Sleeping 80 seconds");
+ Thread.sleep(100000);
+
+ logger.info("testTwoResourcesDifferentPus: Stopping audit threads");
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp1", "pdp2"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testTwoResourcesDifferentPus: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 4);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+ assertTrue("delegate 3 is " + expectedResult.get(3), expectedResult.get(3).equals(delegates.get(3)));
+
+ assertTrue(expectedResult.equals(delegates));
+
+ logger.info("testTwoResourcesDifferentPus: Exiting");
+
+ }
+
+
+ /*
+ * Tests designation logic when two resources are in play but one of them is
+ * dead/hung. Designation should move to second resource but then get
+ * restored back to original resource when it's discovered that second
+ * resource is dead.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test
+ * was successful.
+ */
+ @Ignore
+ @Test
+ public void testTwoResourcesOneDead() throws Exception {
+
+ logger.info("testTwoResourcesOneDead: Entering");
+
+ /*
+ * Start audit for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Populate DB for pdp2, which will simulate it having registered but then having died.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ new DbDAO(resourceName2, persistenceUnit2, properties2);
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 to run audit (15 seconds)
+ *
+ * 2) Logic to detect that other node, pdp2, is not available for designation (60 seconds)
+ *
+ * 3) pdp1 to run audit again (15 seconds)
+ */
+ logger.info("testTwoResourcesOneDead: Sleeping 100 seconds");
+ Thread.sleep(100000);
+
+ logger.info("testTwoResourcesOneDead: Stopping audit thread");
+ integrityAudit.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp1"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testTwoResourcesOneDead: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 2);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+
+ logger.info("testTwoResourcesOneDead: Exiting");
+
+ }
+
+
+ /*
+ * Tests designation logic when three functioning resources are in play. Designation should
+ * round robin among resources.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test was successful.
+ */
+ @Ignore
+ @Test
+ public void testThreeResources() throws Exception {
+
+ logger.info("testThreeResources: Entering");
+
+ /*
+ * Start audit for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Start audit for pdp2.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+ integrityAudit2.startAuditThread();
+
+ /*
+ * Start audit for pdp3.
+ */
+ Properties properties3 = new Properties();
+ properties3.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties3.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties3.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties3.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties3.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties3.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties3.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit3 = "testPU";
+ String resourceName3 = "pdp3";
+ IntegrityAudit integrityAudit3 = new IntegrityAudit(resourceName3, persistenceUnit3, properties3);
+ integrityAudit3.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 to run audit (15 seconds)
+ *
+ * 2) Logic to detect that pdp1 is stale and designate pdp2 (30 seconds)
+ *
+ * 3) pdp2 to run audit (15 seconds)
+ *
+ * 4) Logic to detect that pdp2 is stale and designate pdp3 (30 seconds)
+ *
+ * 5) pdp3 to run audit (15 seconds)
+ *
+ * 6) Logic to detect that pdp3 is stale and designate pdp1 (30 seconds)
+ *
+ * 7) pdp1 to run audit (15 seconds)
+ */
+ logger.info("testThreeResources: Sleeping 160 seconds");
+ Thread.sleep(160000);
+
+ logger.info("testThreeResources: Stopping threads");
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+ integrityAudit3.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testThreeResources: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 3);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+ assertTrue("delegate 3 is " + expectedResult.get(3), expectedResult.get(3).equals(delegates.get(3)));
+
+ logger.info("testThreeResources: Exiting");
+
+ }
+
+ /*
+ * Tests designation logic when four functioning resources are in play, two
+ * with one PU, two with another. Audits for "testPU" and "integrityAuditPU" should run
+ * simultaneously. Designation should alternate between resources for each of the two
+ * persistence units.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test
+ * was successful.
+ */
+ @Ignore
+ @Test
+ public void testFourResourcesDifferentPus() throws Exception {
+
+ logger.info("testFourResourcesDifferentPus: Entering");
+
+ /*
+ * Start audit for pdp1, testPU.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Start audit for pdp2, integrityAuditPU.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "integrityAuditPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+ integrityAudit2.startAuditThread();
+
+ /*
+ * Start audit for pdp3, testPU.
+ */
+ Properties properties3 = new Properties();
+ properties3.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties3.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties3.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties3.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties3.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties3.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties3.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit3 = "testPU";
+ String resourceName3 = "pdp3";
+ IntegrityAudit integrityAudit3 = new IntegrityAudit(resourceName3, persistenceUnit3, properties3);
+ integrityAudit3.startAuditThread();
+
+ /*
+ * Start audit for pdp4, integrityAuditPU.
+ */
+ Properties properties4 = new Properties();
+ properties4.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties4.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties4.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties4.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties4.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties4.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties4.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit4 = "integrityAuditPU";
+ String resourceName4 = "pdp4";
+ IntegrityAudit integrityAudit4 = new IntegrityAudit(resourceName4, persistenceUnit4, properties4);
+ integrityAudit4.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 and pdp2 to run audit simultaneously (15 seconds)
+ *
+ * 2) Logic to detect that pdp1 and pdp2 are stale and designate pdp3 (one's counterpart) and pdp4 (two's counterpart) (30 seconds)
+ *
+ * 3) pdp3 and pdp4 to run audit simultaneously (15 seconds)
+ *
+ * 4) Logic to detect that pdp3 and pdp4 are stale and designate pdp1 (three's counterpart) and pdp2 (four's counterpart) (30 seconds)
+ *
+ * 5) pdp1 and pdp2 to run audit simultaneously (15 seconds)
+ */
+ logger.info("testFourResourcesDifferentPus: Sleeping 120 seconds");
+ Thread.sleep(120000);
+
+ logger.info("testFourResourcesDifferentPus: Stopping threads");
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+ integrityAudit3.stopAuditThread();
+ integrityAudit4.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp4", "pdp1", "pdp2"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate: delegates) {
+ logger.info("testFourResourcesDifferentPus: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 6);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+ assertTrue("delegate 3 is " + expectedResult.get(3), expectedResult.get(3).equals(delegates.get(3)));
+ assertTrue("delegate 4 is " + expectedResult.get(4), expectedResult.get(4).equals(delegates.get(4)));
+ assertTrue("delegate 5 is " + expectedResult.get(5), expectedResult.get(5).equals(delegates.get(5)));
+
+ logger.info("testFourResourcesDifferentPus: Exiting");
+
+ }
+
+ /*
+ * Tests designation logic when four resources are in play but one is not
+ * functioning. Designation should round robin among functioning resources
+ * only.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test
+ * was successful.
+ */
+ @Ignore
+ @Test
+ public void testFourResourcesOneDead() throws Exception {
+
+ logger.info("testFourResourcesOneDead: Entering");
+
+ /*
+ * Start audit for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+ integrityAudit.startAuditThread();
+
+ /*
+ * Start audit for pdp2.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+ integrityAudit2.startAuditThread();
+
+ /*
+ * Populate DB for pdp3, which will simulate it having registered but then having died.
+ */
+ Properties properties3 = new Properties();
+ properties3.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties3.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties3.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties3.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties3.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties3.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties3.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit3 = "testPU";
+ String resourceName3 = "pdp3";
+ new DbDAO(resourceName3, persistenceUnit3, properties3);
+
+ /*
+ * Start audit for pdp4.
+ */
+ Properties properties4 = new Properties();
+ properties4.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties4.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties4.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties4.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties4.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties4.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties4.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit4 = "testPU";
+ String resourceName4 = "pdp4";
+ IntegrityAudit integrityAudit4 = new IntegrityAudit(resourceName4, persistenceUnit4, properties4);
+ integrityAudit4.startAuditThread();
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp1 to run audit (15 seconds)
+ *
+ * 2) Logic to detect that pdp1 is stale and designate pdp2 (30 seconds)
+ *
+ * 3) pdp2 to run audit (15 seconds)
+ *
+ * 4) Logic to detect that pdp2 is stale and designate pdp4 (30 seconds)
+ *
+ * 5) pdp4 to run audit (15 seconds)
+ *
+ * 6) Logic to detect that pdp4 is stale and designate pdp1 (30 seconds)
+ *
+ * 7) pdp1 to run audit (15 seconds)
+ *
+ * 8) Logic to detect that pdp1 is stale and designate pdp2 (30 seconds)
+ *
+ * 7) pdp2 to run audit (15 seconds)
+ */
+ logger.info("testFourResourcesOneDead: Sleeping 210 seconds");
+ Thread.sleep(210000);
+
+ logger.info("testFourResourcesOneDead: Stopping threads");
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+ integrityAudit4.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp4", "pdp1", "pdp2", "pdp4"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate : delegates) {
+ logger.info("testFourResourcesOneDead: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 6);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+ assertTrue("delegate 3 is " + expectedResult.get(3), expectedResult.get(3).equals(delegates.get(3)));
+ assertTrue("delegate 4 is " + expectedResult.get(4), expectedResult.get(4).equals(delegates.get(4)));
+ assertTrue("delegate 5 is " + expectedResult.get(5), expectedResult.get(5).equals(delegates.get(5)));
+
+ logger.info("testFourResourcesOneDead: Exiting");
+
+ }
+
+ /*
+ * Tests designation logic when four resources are in play but only one is
+ * functioning. Designation should remain with sole functioning resource.
+ *
+ * Note: console.log must be examined to ascertain whether or not this test
+ * was successful.
+ */
+ @Ignore
+ @Test
+ public void testFourResourcesThreeDead() throws Exception {
+
+ logger.info("testFourResourcesThreeDead: Entering");
+
+ /*
+ * Populate DB for pdp1, which will simulate it having registered but then having died.
+ */
+ new DbDAO(resourceName, persistenceUnit, properties);
+
+
+ /*
+ * Populate DB for pdp2, which will simulate it having registered but then having died.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ new DbDAO(resourceName2, persistenceUnit2, properties2);
+
+ /*
+ * Start audit for pdp3.
+ */
+ Properties properties3 = new Properties();
+ properties3.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties3.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties3.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties3.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties3.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties3.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties3.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit3 = "testPU";
+ String resourceName3 = "pdp3";
+ IntegrityAudit integrityAudit3 = new IntegrityAudit(resourceName3, persistenceUnit3, properties3);
+ integrityAudit3.startAuditThread();
+
+ /*
+ * Populate DB for pdp4, which will simulate it having registered but then having died.
+ */
+ Properties properties4 = new Properties();
+ properties4.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties4.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties4.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties4.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties4.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties4.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties4.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit4 = "testPU";
+ String resourceName4 = "pdp4";
+ new DbDAO(resourceName4, persistenceUnit4, properties4);
+
+ /*
+ * Sleep long enough to allow
+ *
+ * 1) pdp3 to discover that all other designation candidates are stale (30 seconds)
+ *
+ * 1) pdp3 to run audit (15 seconds)
+ *
+ * 2) Logic to detect that no other nodes are available for designation (60 seconds)
+ *
+ * 3) pdp3 to run audit again (15 seconds)
+ */
+ logger.info("testFourResourcesThreeDead: Sleeping 130 seconds");
+ Thread.sleep(130000);
+
+ logger.info("testFourResourcesThreeDead: Stopping thread");
+ integrityAudit3.stopAuditThread();
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp3", "pdp3"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+
+ for (String delegate : delegates) {
+ logger.info("testFourResourcesThreeDead: delegate: " + delegate);
+ }
+
+ fstream.close();
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 2);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+
+ logger.info("testFourResourcesThreeDead: Exiting");
+
+ }
+
+
+ /*
+ * Tests designation logic when the designated node dies and is no longer
+ * current
+ *
+ * Note: console.log must be examined to ascertain whether or not this test
+ * was successful.
+ */
+ @Ignore
+ @Test
+ public void testDesignatedNodeDead() throws Exception {
+ logger.info("testDesignatedNodeDead: Entering");
+
+ /*
+ * Instantiate audit object for pdp1.
+ */
+ IntegrityAudit integrityAudit = new IntegrityAudit(resourceName, persistenceUnit, properties);
+
+ /*
+ * Start audit for pdp2.
+ */
+ Properties properties2 = new Properties();
+ properties2.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties2.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties2.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties2.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties2.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties2.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties2.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit2 = "testPU";
+ String resourceName2 = "pdp2";
+ IntegrityAudit integrityAudit2 = new IntegrityAudit(resourceName2, persistenceUnit2, properties2);
+
+ /*
+ * Instantiate audit object for pdp3.
+ */
+ Properties properties3 = new Properties();
+ properties3.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
+ properties3.put(IntegrityAuditProperties.DB_URL, IntegrityAuditProperties.DEFAULT_DB_URL);
+ properties3.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
+ properties3.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
+ properties3.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
+ properties3.put(IntegrityAuditProperties.NODE_TYPE, "pdp_xacml");
+ properties3.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "5");
+ String persistenceUnit3 = "testPU";
+ String resourceName3 = "pdp3";
+ IntegrityAudit integrityAudit3 = new IntegrityAudit(resourceName3, persistenceUnit3, properties3);
+
+ // Start audit on pdp1
+ integrityAudit.startAuditThread();
+
+ // Sleep long enough for pdp1 figure out that it should be auditing and start the audit.
+ Thread.sleep(500);
+
+ // Start the auditing threads on other nodes.
+ integrityAudit2.startAuditThread();
+ integrityAudit3.startAuditThread();
+
+ // Sleep long enough to ensure the other two audits have registered.
+ Thread.sleep(500);
+
+ // Kill audit on pdp1
+ integrityAudit.stopAuditThread();
+
+ // Sleep long enough for pdp1 to get stale and pdp2 to take over
+ Thread.sleep(AuditThread.AUDIT_COMPLETION_INTERVAL + FUDGE_FACTOR);
+
+ // Start audit thread on pdp1 again.
+ integrityAudit.startAuditThread();
+
+ // Sleep long enough for pdp2 to complete its audit and get stale, at
+ // which point pdp3 should take over
+ Thread.sleep((AuditThread.AUDIT_SIMULATION_SLEEP_INTERVAL * AuditThread.AUDIT_SIMULATION_ITERATIONS)
+ + AuditThread.AUDIT_COMPLETION_INTERVAL + FUDGE_FACTOR);
+
+ // Kill audit on pdp3
+ logger.info("testDesignatedNodeDead: Killing audit on pdp3");
+ integrityAudit3.stopAuditThread();
+
+ // Sleep long enough for pdp3 to get stale and pdp1 to take over
+ Thread.sleep(AuditThread.AUDIT_COMPLETION_INTERVAL + FUDGE_FACTOR);
+
+ FileInputStream fstream = new FileInputStream(TEST_LOG);
+ BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+ String strLine;
+ int startIndex;
+ int endIndex;
+ ArrayList<String> expectedResult = new ArrayList<String>(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1"));
+ ArrayList<String> delegates = new ArrayList<String>();
+ while ((strLine = br.readLine()) != null) {
+ /* parse strLine to obtain what you want */
+ if (strLine.contains("Starting audit simulation for resourceName=")) {
+ startIndex = strLine.indexOf("resourceName=") + 13;
+ endIndex = strLine.indexOf(",");
+
+ String rName = strLine.substring(startIndex, endIndex);
+
+ delegates.add(rName);
+ }
+ }
+ fstream.close();
+
+ // Stop remaining threads.
+ logger.info("testDesignatedNodeDead: Stopping remaining threads");
+ integrityAudit.stopAuditThread();
+ integrityAudit2.stopAuditThread();
+
+ for (String delegate: delegates) {
+ logger.info("testDesignatedNodeDead: delegate: " + delegate);
+ }
+
+ assertTrue("delegate count only " + delegates.size(), delegates.size() >= 4);
+ assertTrue("delegate 0 is " + expectedResult.get(0), expectedResult.get(0).equals(delegates.get(0)));
+ assertTrue("delegate 1 is " + expectedResult.get(1), expectedResult.get(1).equals(delegates.get(1)));
+ assertTrue("delegate 2 is " + expectedResult.get(2), expectedResult.get(2).equals(delegates.get(2)));
+ assertTrue("delegate 3 is " + expectedResult.get(3), expectedResult.get(3).equals(delegates.get(3)));
+
+ logger.info("testDesignatedNodeDead: Exiting");
+ }
+}
diff --git a/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/IaTestEntity.java b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/IaTestEntity.java
new file mode 100644
index 00000000..e875fa3d
--- /dev/null
+++ b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/IaTestEntity.java
@@ -0,0 +1,163 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.common.ia.test.jpa;
+
+import java.io.Serializable;
+import java.util.Date;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Lob;
+import javax.persistence.NamedQueries;
+import javax.persistence.NamedQuery;
+import javax.persistence.PrePersist;
+import javax.persistence.PreUpdate;
+import javax.persistence.SequenceGenerator;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Version;
+/*
+ * The Entity class to persist a policy object Action Body
+ */
+
+@Entity
+@Table(name="IaTestEntity")
+@NamedQueries({
+ @NamedQuery(name=" IaTestEntity.findAll", query="SELECT e FROM IaTestEntity e "),
+ @NamedQuery(name="IaTestEntity.deleteAll", query="DELETE FROM IaTestEntity WHERE 1=1")
+})
+//@SequenceGenerator(name="seqImTest", initialValue=1, allocationSize=1)
+
+public class IaTestEntity implements Serializable {
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ //@GeneratedValue(strategy = GenerationType.SEQUENCE, generator="seqImTest")
+ @GeneratedValue(strategy = GenerationType.AUTO)
+ @Column(name="ImTestId")
+ private long imTestId;
+
+ @Column(name="created_by", nullable=false, length=255)
+ private String createdBy = "guest";
+
+ @Column(name="person", nullable=false, length=255)
+ private PersonTest person;
+
+ @Temporal(TemporalType.TIMESTAMP)
+ @Column(name="created_date", updatable=false)
+ private Date createdDate;
+
+ @Column(name="modified_by", nullable=false, length=255)
+ private String modifiedBy = "guest";
+
+ @Temporal(TemporalType.TIMESTAMP)
+ @Column(name="modified_date", nullable=false)
+ private Date modifiedDate;
+
+ public IaTestEntity() {
+ }
+
+ @PrePersist
+ public void prePersist() {
+ Date date = new Date();
+ this.createdDate = date;
+ this.modifiedDate = date;
+ }
+
+ @PreUpdate
+ public void preUpdate() {
+ this.modifiedDate = new Date();
+ }
+
+ /**
+ * @return the Id
+ */
+ public long getImTestId() {
+ return imTestId;
+ }
+
+ /**
+ * @return the createdBy
+ */
+ public String getCreatedBy() {
+ return createdBy;
+ }
+
+ /**
+ * @param createdBy the createdBy to set
+ */
+ public void setCreatedBy(String createdBy) {
+ this.createdBy = createdBy;
+ }
+
+ /**
+ * @return the modifiedBy
+ */
+ public String getModifiedBy() {
+ return modifiedBy;
+ }
+
+ /**
+ * @param modifiedBy the modifiedBy to set
+ */
+ public void setModifiedBy(String modifiedBy) {
+ this.modifiedBy = modifiedBy;
+ }
+
+ /**
+ * @return the modifiedDate
+ */
+ public Date getModifiedDate() {
+ return modifiedDate;
+ }
+
+ /**
+ * @param modifiedDate the modifiedDate to set
+ */
+ public void setModifiedDate(Date modifiedDate) {
+ this.modifiedDate = modifiedDate;
+ }
+
+ /**
+ * @return the createdDate
+ */
+ public Date getCreatedDate() {
+ return createdDate;
+ }
+
+ /**
+ * @param the person to set
+ */
+ public void setPersonTest(PersonTest p) {
+ this.person = p;
+ }
+
+ /**
+ * @return the person
+ */
+ public PersonTest getPersonTest() {
+ return person;
+ }
+}
diff --git a/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/PersonTest.java b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/PersonTest.java
new file mode 100644
index 00000000..7ec5e294
--- /dev/null
+++ b/integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/PersonTest.java
@@ -0,0 +1,64 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.common.ia.test.jpa;
+
+import java.io.Serializable;
+
+public class PersonTest implements Serializable {
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private String firstName;
+ private String lastName;
+ private int age;
+
+ public PersonTest(String first, String last, int age) {
+ this.firstName = first;
+ this.lastName = last;
+ this.age = age;
+ }
+
+ public String getFirstName() {
+ return this.firstName;
+ }
+
+ public void setFirstName(String name) {
+ this.firstName = name;
+ }
+
+ public String getLasttName() {
+ return this.lastName;
+ }
+
+ public void setLastName(String name) {
+ this.lastName = name;
+ }
+
+ public int getAge() {
+ return this.age;
+ }
+
+ public void setAge(int age) {
+ this.age = age;
+ }
+
+}