From f6016415a09828385e3fb5603597cc9b238f150c Mon Sep 17 00:00:00 2001 From: Pamela Dragosh Date: Sun, 19 Feb 2017 16:40:30 -0500 Subject: adding back in unit tests with ignore Change-Id: Ib81e9a63869b8a97b858d204e38637acd5483083 Signed-off-by: Pamela Dragosh --- .../policy/common/ia/test/AuditPeriodTest.java | 475 +++++ .../common/ia/test/DbAuditCompareEntriesTest.java | 615 ++++++ .../policy/common/ia/test/DbAuditTest.java | 749 +++++++ .../openecomp/policy/common/ia/test/DbDAOTest.java | 725 +++++++ .../ia/test/IntegrityAuditDesignationTest.java | 1101 ++++++++++ .../policy/common/ia/test/jpa/IaTestEntity.java | 163 ++ .../policy/common/ia/test/jpa/PersonTest.java | 64 + .../common/im/test/IntegrityMonitorTest.java | 734 +++++++ .../common/im/test/StateManagementEntityTest.java | 197 ++ .../policy/common/im/test/StateManagementTest.java | 338 +++ .../policy/common/im/test/StateTransitionTest.java | 2188 ++++++++++++++++++++ 11 files changed, 7349 insertions(+) create mode 100644 integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/AuditPeriodTest.java create mode 100644 integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditCompareEntriesTest.java create mode 100644 integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbAuditTest.java create mode 100644 integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/DbDAOTest.java create mode 100644 integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/IntegrityAuditDesignationTest.java create mode 100644 integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/IaTestEntity.java create mode 100644 integrity-audit/src/test/java/org/openecomp/policy/common/ia/test/jpa/PersonTest.java create mode 100644 integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/IntegrityMonitorTest.java create mode 100644 integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementEntityTest.java create mode 100644 integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementTest.java create mode 100644 integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateTransitionTest.java 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 expectedResult = new ArrayList(Arrays.asList("-1")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1", "pdp2", "pdp3")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1", "pdp2", "pdp3")); + ArrayList delegates = new ArrayList(); + 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 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 myEntries = new HashMap(); + HashMap theirEntries = new HashMap(); + + myEntries.put("pdp1", entry1); + theirEntries.put("pdp1", entry2); + + HashSet 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 myEntries = new HashMap(); + HashMap theirEntries = new HashMap(); + + myEntries.put("pdp1", entry1); + theirEntries.put("pdp1", entry2); + + HashSet 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 myEntries = new HashMap(); + HashMap theirEntries = new HashMap(); + + myEntries.put("0", entry1); + myEntries.put("1", entry3); + theirEntries.put("0", entry2); + theirEntries.put("2", entry4); + + HashSet 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 classNameSet = dbDAO.getPersistenceClassNames(); + HashSet mismatchResult = new HashSet(); + 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 myEntries = new HashMap(); + HashMap theirEntries = new HashMap(); + + 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 myEntries = new HashMap(); + HashMap theirEntries = new HashMap(); + + 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 classNameSet = dbDAO.getPersistenceClassNames(); + HashMap myEntries; + HashMap theirEntries; + HashSet mismatchResult = new HashSet(); + 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 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 myEntries = new HashMap(); + HashMap theirEntries = new HashMap(); + + myEntries.put("0", iate); + theirEntries.put("0", iate2); + + HashSet 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 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 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 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 cq = cb.createQuery(); + Root rootEntry = cq.from(Class.forName("org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity")); + CriteriaQuery all = cq.select(rootEntry); + TypedQuery allQuery = em.createQuery(all); + List objectList = allQuery.getResultList(); + HashSet resultSet = new HashSet(); + PersistenceUnitUtil util = emf.getPersistenceUnitUtil(); + for (Object o: objectList){ + Object key = util.getIdentifier(o); + resultSet.add(key); + } + + // Obtain a hash with the persisted objects + HashMap 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 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 cq = cb.createQuery(); + Root rootEntry = cq.from(Class.forName("org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity")); + CriteriaQuery all = cq.select(rootEntry); + TypedQuery allQuery = em.createQuery(all); + List objectList = allQuery.getResultList(); + HashSet resultSet = new HashSet(); + PersistenceUnitUtil util = emf.getPersistenceUnitUtil(); + for (Object o: objectList){ + Object key = util.getIdentifier(o); + resultSet.add(key); + } + + // Obtain a hash with the persisted objects + HashMap 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 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 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp1")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp1", "pdp2")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp1")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp4", "pdp1", "pdp2")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp4", "pdp1", "pdp2", "pdp4")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp3", "pdp3")); + ArrayList delegates = new ArrayList(); + 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 expectedResult = new ArrayList(Arrays.asList("pdp1", "pdp2", "pdp3", "pdp1")); + ArrayList delegates = new ArrayList(); + 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; + } + +} diff --git a/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/IntegrityMonitorTest.java b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/IntegrityMonitorTest.java new file mode 100644 index 00000000..68a6cf2f --- /dev/null +++ b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/IntegrityMonitorTest.java @@ -0,0 +1,734 @@ +/*- + * ============LICENSE_START======================================================= + * Integrity Monitor + * ================================================================================ + * 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.im.test; + +import static org.junit.Assert.*; + +import java.util.Date; +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.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +//import org.apache.commons.logging.Log; +//import org.apache.commons.logging.LogFactory; + + + +import org.openecomp.policy.common.im.IntegrityMonitor; +import org.openecomp.policy.common.im.IntegrityMonitorProperties; +import org.openecomp.policy.common.im.StateManagement; +import org.openecomp.policy.common.im.jpa.ForwardProgressEntity; +import org.openecomp.policy.common.im.jpa.ImTestEntity; +import org.openecomp.policy.common.im.jpa.ResourceRegistrationEntity; +import org.openecomp.policy.common.im.jpa.StateManagementEntity; +import org.openecomp.policy.common.logging.flexlogger.FlexLogger; +import org.openecomp.policy.common.logging.flexlogger.Logger; + +public class IntegrityMonitorTest { + private static Logger logger = FlexLogger.getLogger(IntegrityMonitorTest.class); + private static Properties myProp; + private static EntityManagerFactory emf; + private static EntityManager em; + private static EntityTransaction et; + private static String resourceName; + private static Properties systemProps; + + @BeforeClass + public static void setUpClass() throws Exception { + + } + + @AfterClass + public static void tearDownClass() throws Exception { + } + + @Before + public void setUp() throws Exception { + IntegrityMonitor.isUnitTesting = true; + + myProp = new Properties(); + myProp.put(IntegrityMonitorProperties.DB_DRIVER, IntegrityMonitorProperties.DEFAULT_DB_DRIVER); + myProp.put(IntegrityMonitorProperties.DB_URL, IntegrityMonitorProperties.DEFAULT_DB_URL); + myProp.put(IntegrityMonitorProperties.DB_USER, IntegrityMonitorProperties.DEFAULT_DB_USER); + myProp.put(IntegrityMonitorProperties.DB_PWD, IntegrityMonitorProperties.DEFAULT_DB_PWD); + myProp.put(IntegrityMonitorProperties.SITE_NAME, "SiteA"); + myProp.put(IntegrityMonitorProperties.NODE_TYPE, "pap"); + + // set JMX remote port in system properties + systemProps = System.getProperties(); + systemProps.put("com.sun.management.jmxremote.port", "9797"); + + resourceName = "siteA.pap1"; + + //Create the data schema and entity manager factory + emf = Persistence.createEntityManagerFactory("schemaPU", myProp); + + // Create an entity manager to use the DB + em = emf.createEntityManager(); + + } + + + @After + public void tearDown() throws Exception { + // clear jmx remote port setting + systemProps.remove("com.sun.management.jmxremote.port"); + } + + /* + * The following test verifies the following test cases: + * New Install + * New Install - Bad Dependency data + * Recovery from bad dependency data + * Lock + * Lock restart + * Unlock + * Unlock restart + */ + @Ignore // Test passed 10/18/16 + @Test + public void testSanityJmx() throws Exception { + System.out.println("\nIntegrityMonitorTest: Entering testSanityJmx\n\n"); + + String dependent = "group1_logparser"; + + // parameters are passed via a properties file + myProp.put(IntegrityMonitorProperties.DEPENDENCY_GROUPS, dependent); + myProp.put(IntegrityMonitorProperties.TEST_VIA_JMX, "true"); + IntegrityMonitor.updateProperties(myProp); + + IntegrityMonitor im = IntegrityMonitor.getInstance(resourceName, myProp); + System.out.println("\n\ntestSanityJmx starting im state" + + "\nAdminState = " + im.getStateManager().getAdminState() + + "\nOpState() = " + im.getStateManager().getOpState() + + "\nAvailStatus = " + im.getStateManager().getAvailStatus() + + "\nStandbyStatus = " + im.getStateManager().getStandbyStatus() + + "\n"); + // add an entry to Resource registration table in the DB for the dependent resource + + + et = em.getTransaction(); + et.begin(); + Query rquery = em.createQuery("Select r from ResourceRegistrationEntity r where r.resourceName=:rn"); + rquery.setParameter("rn", dependent); + + @SuppressWarnings("rawtypes") + List rrList = rquery.getResultList(); + ResourceRegistrationEntity rrx = null; + if(rrList.isEmpty()){ + // register resource by adding entry to table in DB + System.out.println("Adding resource " + dependent + " to ResourceRegistration table"); + rrx = new ResourceRegistrationEntity(); + // set columns in entry + rrx.setResourceName(dependent); + rrx.setResourceUrl("service:jmx:somewhere:9999"); + rrx.setNodeType("logparser"); + rrx.setSite("siteA"); + } + em.persist(rrx); + // flush to the DB + em.flush(); + + // commit transaction + et.commit(); + + Thread.sleep(15000); //sleep 15 sec so the FPManager has time to call evaluateSanty() + + boolean sanityPass = true; + try { + im.evaluateSanity(); + } catch (Exception e) { + System.out.println("evaluateSanity exception: " + e); + sanityPass = false; + } + assertFalse(sanityPass); // expect sanity test to fail + + // undo dependency groups and jmx test properties settings + myProp.put(IntegrityMonitorProperties.DEPENDENCY_GROUPS, ""); + myProp.put(IntegrityMonitorProperties.TEST_VIA_JMX, "false"); + IntegrityMonitor.updateProperties(myProp); + + System.out.println("\ntestSantityJmx ending properties: " + myProp); + + //We know at this point that the IM is disable-dependency. We want to be + //sure it will recover from this condition since the properties were + //updated. + + + System.out.println("\n\ntestSanityJmx ending im state" + + "\nAdminState = " + im.getStateManager().getAdminState() + + "\nOpState() = " + im.getStateManager().getOpState() + + "\nAvailStatus = " + im.getStateManager().getAvailStatus() + + "\nStandbyStatus = " + im.getStateManager().getStandbyStatus() + + "\n"); + + //Destroy the instance + System.out.println("\ntestSanityJmx restarting the IntegrityMonitor"); + IntegrityMonitor.deleteInstance(); + //Create a new instance. It should recover from the disabled-dependency condition + im = IntegrityMonitor.getInstance(resourceName, myProp); + + System.out.println("\n\ntestSanityJmx state after creating new im" + + "\nAdminState = " + im.getStateManager().getAdminState() + + "\nOpState() = " + im.getStateManager().getOpState() + + "\nAvailStatus = " + im.getStateManager().getAvailStatus() + + "\nStandbyStatus = " + im.getStateManager().getStandbyStatus() + + "\n"); + + //Verify the state + assertEquals(im.getStateManager().getAdminState(), StateManagement.UNLOCKED); + assertEquals(im.getStateManager().getOpState(), StateManagement.ENABLED); + assertEquals(im.getStateManager().getAvailStatus(), StateManagement.NULL_VALUE); + assertEquals(im.getStateManager().getStandbyStatus(), StateManagement.NULL_VALUE); + + //Test state manager via the IntegrityMonitor + StateManagement sm = im.getStateManager(); + + // Verify lock state + sm.lock(); + System.out.println("\n\nsm.lock()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAdminState().equals(StateManagement.LOCKED)); + + //Verify lock persists across a restart + //Destroy the instance + System.out.println("\ntestSanityJmx restarting the IntegrityMonitor"); + IntegrityMonitor.deleteInstance(); + //Create a new instance. It should come up with the admin state locked + im = IntegrityMonitor.getInstance(resourceName, myProp); + sm = im.getStateManager(); + System.out.println("\n\ntestSanityJmx restart with AdminState=locked" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAdminState().equals(StateManagement.LOCKED)); + + // Verify unlock + sm.unlock(); + System.out.println("\n\ntestSanityJmx sm.unlock" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAdminState().equals(StateManagement.UNLOCKED)); + + // Verify unlock restart + //Destroy the instance + System.out.println("\ntestSanityJmx restarting the IntegrityMonitor"); + IntegrityMonitor.deleteInstance(); + //Create a new instance. It should come up with the admin state locked + im = IntegrityMonitor.getInstance(resourceName, myProp); + sm = im.getStateManager(); + System.out.println("\n\ntestSanityJmx restart with AdminState=unlocked" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAdminState().equals(StateManagement.UNLOCKED)); + + System.out.println("\n\ntestSanityJmx: Exit\n\n"); + } + + + @Ignore // Test passed 10/18/16 + @Test + public void testIM() throws Exception { + System.out.println("\nIntegrityMonitorTest: Entering testIM\n\n"); + + // parameters are passed via a properties file + + /* + * Create an IntegrityMonitor + * NOTE: This uses the database that was created above. So, this MUST follow the creation + * of the DB + */ + IntegrityMonitor im = IntegrityMonitor.getInstance(resourceName, myProp); + + System.out.println("\n\nim before sleep" + + "\nAdminState = " + im.getStateManager().getAdminState() + + "\nOpState() = " + im.getStateManager().getOpState() + + "\nAvailStatus = " + im.getStateManager().getAvailStatus() + + "\nStandbyStatus = " + im.getStateManager().getStandbyStatus() + + "\n"); + + // wait for test transactions to fire and increment fpc + Thread.sleep(20000); + + System.out.println("\n\nim after sleep" + + "\nAdminState = " + im.getStateManager().getAdminState() + + "\nOpState() = " + im.getStateManager().getOpState() + + "\nAvailStatus = " + im.getStateManager().getAvailStatus() + + "\nStandbyStatus = " + im.getStateManager().getStandbyStatus() + + "\n"); + + // test evaluate sanity + boolean sanityPass = true; + try { + im.evaluateSanity(); + } catch (Exception e) { + System.out.println("evaluateSanity exception: " + e); + sanityPass = false; + } + assertTrue(sanityPass); // expect sanity test to pass + + //Test startTransaction - should works since it is unlocked + boolean transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(transPass); + + //Test state manager via the IntegrityMonitor + StateManagement sm = im.getStateManager(); + + sm.lock(); + System.out.println("\n\nsm.lock()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAdminState().equals(StateManagement.LOCKED)); + + //test startTransaction. It should fail since it is locked + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(!transPass); //expect it to fail + + sm.unlock(); + System.out.println("\n\nsm.unlock()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAdminState().equals(StateManagement.UNLOCKED)); + + //test startTransaction. It should succeed + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(transPass); //expect it to succeed + + sm.disableDependency(); + System.out.println("\n\nsm.disableDependency()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getOpState().equals(StateManagement.DISABLED)); + assert(sm.getAvailStatus().equals(StateManagement.DEPENDENCY)); + + //test startTransaction. It should succeed since standby status is null and unlocked + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(transPass); //expect it to succeed + + sm.enableNoDependency(); + System.out.println("\n\nsm.enableNoDependency()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getOpState().equals(StateManagement.ENABLED)); + //test startTransaction. It should succeed since standby status is null and unlocked + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(transPass); //expect it to succeed + + + sm.disableFailed(); + System.out.println("\n\nsm.disableFailed()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getOpState().equals(StateManagement.DISABLED)); + assert(sm.getAvailStatus().equals(StateManagement.FAILED)); + //test startTransaction. It should succeed since standby status is null and unlocked + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(transPass); //expect it to succeed + + sm.enableNotFailed(); + System.out.println("\n\nsm.enabledNotFailed()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getOpState().equals(StateManagement.ENABLED)); + //test startTransaction. It should succeed since standby status is null and unlocked + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(transPass); //expect it to succeed + + sm.demote(); + System.out.println("\n\nsm.demote()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getStandbyStatus().equals(StateManagement.HOT_STANDBY)); + + //test startTransaction. It should fail since it is standby + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(!transPass); //expect it to fail + + sm.promote(); + System.out.println("\n\nsm.promote()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getStandbyStatus().equals(StateManagement.PROVIDING_SERVICE)); + + //test startTransaction. It should succeed since it is providing service + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(transPass); //expect it to succeed + + + //Test the multi-valued availability status + sm.disableDependency(); + sm.disableFailed(); + System.out.println("\n\nsm.disableDependency(), sm.disableFailed" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAvailStatus().equals(StateManagement.DEPENDENCY_FAILED)); + + //Test startTransaction. Should fail since standby status is cold standby + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(!transPass); //expect it to fail + + sm.enableNoDependency(); + System.out.println("\n\nsm.enableNoDependency()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAvailStatus().equals(StateManagement.FAILED)); + //Test startTransaction. Should fail since standby status is cold standby + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(!transPass); //expect it to fail + + sm.disableDependency(); + sm.enableNotFailed(); + System.out.println("\n\nsm.disableDependency(),sm.enableNotFailed()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getAvailStatus().equals(StateManagement.DEPENDENCY)); + //Test startTransaction. Should fail since standby status is cold standby + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(!transPass); //expect it to fail + + sm.enableNoDependency(); + System.out.println("\n\nsm.enableNoDependency()" + + "\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + assert(sm.getOpState().equals(StateManagement.ENABLED)); + //test startTransaction. It should fail since standby status is hot standby + transPass = true; + try{ + im.startTransaction(); + } catch (Exception e){ + System.out.println("startTransaction exception: " + e); + transPass = false; + } + assertTrue(!transPass); //expect it to fail + + System.out.println("\n\ntestIM: Exit\n\n"); + } + + + @Ignore // Test passed 10/18/16 + @Test + public void testSanityState() throws Exception { + System.out.println("\nIntegrityMonitorTest: Entering testSanityState\n\n"); + + // parameters are passed via a properties file + myProp.put(IntegrityMonitorProperties.DEPENDENCY_GROUPS, "group1_dep1,group1_dep2; group2_dep1"); + IntegrityMonitor.updateProperties(myProp); + + IntegrityMonitor im = IntegrityMonitor.getInstance(resourceName, myProp); + + // Add a group1 dependent resources to put an entry in the forward progress table + ForwardProgressEntity fpe = new ForwardProgressEntity(); + ForwardProgressEntity fpe2 = new ForwardProgressEntity(); + fpe.setFpcCount(0); + fpe.setResourceName("group1_dep1"); + fpe2.setFpcCount(0); + fpe2.setResourceName("group1_dep2"); + et = em.getTransaction(); + et.begin(); + em.persist(fpe); + em.persist(fpe2); + em.flush(); + et.commit(); + + + // Add a group2 dependent resource to the StateManagementEntity DB table and set its admin state to locked + // Expect sanity test to fail. + StateManagement stateManager = new StateManagement(emf, "group2_dep1"); + stateManager.lock(); + + //Now add new group1 stateManager instances + StateManagement sm2 = new StateManagement(emf, "group1_dep1"); + StateManagement sm3 = new StateManagement(emf, "group1_dep2"); + + boolean sanityPass = true; + Thread.sleep(15000); + try { + im.evaluateSanity(); + } catch (Exception e) { + System.out.println("evaluateSanity exception: " + e); + sanityPass = false; + } + assertFalse(sanityPass); // expect sanity test to fail + + // undo dependency groups and jmx test properties settings + myProp.put(IntegrityMonitorProperties.DEPENDENCY_GROUPS, ""); + myProp.put(IntegrityMonitorProperties.TEST_VIA_JMX, "false"); + IntegrityMonitor.updateProperties(myProp); + + et = em.getTransaction(); + + et.begin(); + // Make sure we leave the DB clean + em.createQuery("DELETE FROM StateManagementEntity").executeUpdate(); + em.createQuery("DELETE FROM ResourceRegistrationEntity").executeUpdate(); + em.createQuery("DELETE FROM ForwardProgressEntity").executeUpdate(); + + em.flush(); + et.commit(); + + System.out.println("\n\ntestSanityState: Exit\n\n"); + } + + @Ignore // Test passed 10/18/16 + @Test + public void testRefreshStateAudit() throws Exception { + logger.debug("\nIntegrityMonitorTest: testRefreshStateAudit Enter\n\n"); + + // parameters are passed via a properties file + myProp.put(IntegrityMonitorProperties.DEPENDENCY_GROUPS, ""); + myProp.put(IntegrityMonitorProperties.TEST_VIA_JMX, "false"); + IntegrityMonitor.updateProperties(myProp); + + et = em.getTransaction(); + et.begin(); + + // Make sure we leave the DB clean + em.createQuery("DELETE FROM StateManagementEntity").executeUpdate(); + em.createQuery("DELETE FROM ResourceRegistrationEntity").executeUpdate(); + em.createQuery("DELETE FROM ForwardProgressEntity").executeUpdate(); + + em.flush(); + et.commit(); + + IntegrityMonitor.deleteInstance(); + + IntegrityMonitor im = IntegrityMonitor.getInstance(resourceName, myProp); + + //the state here is unlocked, enabled, null, null + StateManagementEntity sme = null; + + Query query = em.createQuery("Select p from StateManagementEntity p where p.resourceName=:resource"); + + query.setParameter("resource", resourceName); + + //Just test that we are retrieving the right object + @SuppressWarnings("rawtypes") + List resourceList = query.getResultList(); + if (!resourceList.isEmpty()) { + // exist + sme = (StateManagementEntity) resourceList.get(0); + em.refresh(sme); + + logger.debug("??? -- Retrieve StateManagementEntity from database --" + + "\nsme.getResourceName() = " + sme.getResourceName() + + "\nsme.getAdminState() = " + sme.getAdminState() + + "\nsme.getOpState() = " + sme.getOpState() + + "\nsme.getAvailStatus() = " + sme.getAvailStatus() + + "\nsme.getStandbyStatus() = " + sme.getStandbyStatus()); + + assertTrue(sme.getAdminState().equals(StateManagement.UNLOCKED)); + assertTrue(sme.getOpState().equals(StateManagement.ENABLED)); + assertTrue(sme.getAvailStatus().equals(StateManagement.NULL_VALUE)); + assertTrue(sme.getStandbyStatus().equals(StateManagement.NULL_VALUE)); + logger.debug("--"); + } else { + logger.debug("Record not found, resourceName: " + resourceName); + assertTrue(false); + } + + et = em.getTransaction(); + et.begin(); + + sme.setStandbyStatus(StateManagement.COLD_STANDBY); + em.persist(sme); + em.flush(); + et.commit(); + + Thread.sleep(65000); + + //The refreshStateAudit should run and change the state to unlocked,enabled,null,hotstandby + StateManagementEntity sme1 = null; + + Query query1 = em.createQuery("Select p from StateManagementEntity p where p.resourceName=:resource"); + + query1.setParameter("resource", resourceName); + + //Just test that we are retrieving the right object + @SuppressWarnings("rawtypes") + List resourceList1 = query1.getResultList(); + if (!resourceList1.isEmpty()) { + // exist + sme1 = (StateManagementEntity) resourceList1.get(0); + em.refresh(sme1); + logger.debug("??? -- Retrieve StateManagementEntity from database --" + + "\nsme1.getResourceName() = " + sme1.getResourceName() + + "\nsme1.getAdminState() = " + sme1.getAdminState() + + "\nsme1.getOpState() = " + sme1.getOpState() + + "\nsme1.getAvailStatus() = " + sme1.getAvailStatus() + + "\nsme1.getStandbyStatus() = " + sme1.getStandbyStatus()); + + assertTrue(sme1.getAdminState().equals(StateManagement.UNLOCKED)); + assertTrue(sme1.getOpState().equals(StateManagement.ENABLED)); + assertTrue(sme1.getAvailStatus().equals(StateManagement.NULL_VALUE)); + assertTrue(sme1.getStandbyStatus().equals(StateManagement.HOT_STANDBY)); + logger.debug("--"); + } else { + logger.debug("Record not found, resourceName: " + resourceName); + assertTrue(false); + } + + et = em.getTransaction(); + et.begin(); + + // Make sure we leave the DB clean + em.createQuery("DELETE FROM StateManagementEntity").executeUpdate(); + em.createQuery("DELETE FROM ResourceRegistrationEntity").executeUpdate(); + em.createQuery("DELETE FROM ForwardProgressEntity").executeUpdate(); + + em.flush(); + et.commit(); + + IntegrityMonitor.deleteInstance(); + + logger.debug("\nIntegrityMonitorTest: testRefreshStateAudit Exit\n\n"); + } +} diff --git a/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementEntityTest.java b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementEntityTest.java new file mode 100644 index 00000000..b4222568 --- /dev/null +++ b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementEntityTest.java @@ -0,0 +1,197 @@ +/*- + * ============LICENSE_START======================================================= + * Integrity Monitor + * ================================================================================ + * 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.im.test; + +import static org.junit.Assert.*; + +import java.util.Date; +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.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +//import org.apache.commons.logging.Log; +//import org.apache.commons.logging.LogFactory; + +import org.openecomp.policy.common.im.StateManagement; +import org.openecomp.policy.common.im.jpa.StateManagementEntity; +import org.openecomp.policy.common.logging.flexlogger.FlexLogger; +import org.openecomp.policy.common.logging.flexlogger.Logger; + +public class StateManagementEntityTest { + private static Logger logger = FlexLogger.getLogger(StateManagementEntityTest.class); + + private static final String DEFAULT_DB_DRIVER = "org.h2.Driver"; + private static final String DEFAULT_DB_URL = "jdbc:h2:file:./sql/smTest"; + //private static final String DEFAULT_DB_URL = "jdbc:h2:file:./sql/xacml"; + private static final String DEFAULT_DB_USER = "sa"; + private static final String DEFAULT_DB_PWD = ""; + + /* + private static final String DEFAULT_DB_DRIVER = "org.mariadb.jdbc.Driver"; + private static final String DEFAULT_DB_URL = "jdbc:mariadb://localhost:3306/xacml"; + private static final String DEFAULT_DB_USER = "policy_user"; + private static final String DEFAULT_DB_PWD = "policy_user"; + */ + + private static final String DB_DRIVER = "javax.persistence.jdbc.driver"; + private static final String DB_URL = "javax.persistence.jdbc.url"; + private static final String DB_USER = "javax.persistence.jdbc.user"; + private static final String DB_PWD = "javax.persistence.jdbc.password"; + + @BeforeClass + public static void setUpClass() throws Exception { + + } + + @AfterClass + public static void tearDownClass() throws Exception { + } + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } + + @Ignore + @Test + public void testJPA() throws Exception { + System.out.println("\n??? logger.infor StateManagementEntityTest: Entering\n\n"); + + Properties myProp = new Properties(); + myProp.put(DB_DRIVER, DEFAULT_DB_DRIVER); + myProp.put(DB_URL, DEFAULT_DB_URL); + myProp.put(DB_USER, DEFAULT_DB_USER); + myProp.put(DB_PWD, DEFAULT_DB_PWD); + + System.out.println("??? " + DB_DRIVER + "=" + DEFAULT_DB_DRIVER); + System.out.println("??? " + DB_URL + "=" + DEFAULT_DB_URL); + System.out.println("??? " + DB_USER + "=" + DEFAULT_DB_USER); + System.out.println("??? " + DB_PWD + "=" + DEFAULT_DB_PWD); + + //Create the data schema and entity manager factory + System.out.println("??? createEntityManagerFactory for schemaPU"); + EntityManagerFactory emf = Persistence.createEntityManagerFactory("schemaPU", myProp); + + // Create an entity manager to use the DB + System.out.println("??? createEntityManager"); + EntityManager em = emf.createEntityManager(); + System.out.println("??? getTransaction"); + EntityTransaction et = em.getTransaction(); + et.begin(); + // Make sure the DB is clean + System.out.println("??? clean StateManagementEntity"); + em.createQuery("DELETE FROM StateManagementEntity").executeUpdate(); + + //Define the resourceName for the StateManagement constructor + String resourceName = "test_resource1"; + + // + System.out.println("Create StateManagementEntity, resourceName: " + resourceName); + System.out.println("??? instantiate StateManagementEntity object"); + StateManagementEntity sme = new StateManagementEntity(); + + System.out.println("??? setResourceName : " + resourceName); + sme.setResourceName(resourceName); + System.out.println("??? getResourceName : " + sme.getResourceName()); + + System.out.println("??? setAdminState : " + StateManagement.UNLOCKED); + sme.setAdminState(StateManagement.UNLOCKED); + System.out.println("??? getAdminState : " + sme.getAdminState()); + + System.out.println("??? setOpState : " + StateManagement.ENABLED); + sme.setOpState(StateManagement.ENABLED); + System.out.println("??? getOpState : " + sme.getOpState()); + + System.out.println("??? setAvailStatus : " + StateManagement.NULL_VALUE); + sme.setAvailStatus(StateManagement.NULL_VALUE); + System.out.println("??? getAvailStatus : " + sme.getAvailStatus()); + + System.out.println("??? setStandbyStatus: " + StateManagement.COLD_STANDBY); + sme.setStandbyStatus(StateManagement.COLD_STANDBY); + System.out.println("??? getStandbyStatus: " + sme.getStandbyStatus()); + + System.out.println("??? before persist"); + em.persist(sme); + System.out.println("??? after persist"); + + em.flush(); + System.out.println("??? after flush"); + + et.commit(); + System.out.println("??? after commit"); + + try { + Query query = em.createQuery("Select p from StateManagementEntity p where p.resourceName=:resource"); + + query.setParameter("resource", resourceName); + + //Just test that we are retrieving the right object + @SuppressWarnings("rawtypes") + List resourceList = query.getResultList(); + String resource = null; + if (!resourceList.isEmpty()) { + // exist + StateManagementEntity sme2 = (StateManagementEntity) resourceList.get(0); + System.out.println("??? -- Retrieve StateManagementEntity from database --" + + "\n\nsme.getResourceName() = " + sme.getResourceName() + + "\nsme2getResourceName() = " + sme2.getResourceName() + + "\n\nsme.getAdminState() = " + sme.getAdminState() + + "\nsme2.getAdminState() = " + sme2.getAdminState() + + "\n\nsme.getOpState() = " + sme.getOpState() + + "\nsme2.getOpState() = " + sme2.getOpState() + + "\n\nsme.getAvailStatus() = " + sme.getAvailStatus() + + "\nsme2.getAvailStatus() = " + sme.getAvailStatus() + + "\n\nsme.getStandbyStatus() = " + sme.getStandbyStatus() + + "\nsme2.getStandbyStatus() = " + sme2.getStandbyStatus()); + + + assert(sme2.getResourceName().equals(sme.getResourceName())); + assert(sme2.getAdminState().equals(sme.getAdminState())); + assert(sme2.getOpState().equals(sme.getOpState())); + assert(sme2.getAvailStatus().equals(sme.getAvailStatus())); + assert(sme2.getStandbyStatus().equals(sme.getStandbyStatus())); + System.out.println("--"); + } else { + System.out.println("Record not found, resourceName: " + resourceName); + } + } catch(Exception ex) { + logger.error("Exception on select query: " + ex.toString()); + } + + em.close(); + System.out.println("\n??? after close"); + System.out.println("\n\nJpaTest: Exit\n\n"); + } +} diff --git a/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementTest.java b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementTest.java new file mode 100644 index 00000000..3247d781 --- /dev/null +++ b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateManagementTest.java @@ -0,0 +1,338 @@ +/*- + * ============LICENSE_START======================================================= + * Integrity Monitor + * ================================================================================ + * 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.im.test; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; +import java.util.StringTokenizer; +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.Persistence; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.LockModeType; +import javax.persistence.PersistenceException; +import javax.persistence.Query; + + + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.openecomp.policy.common.im.StateManagement; +import org.openecomp.policy.common.im.StateTransition; +import org.openecomp.policy.common.im.StandbyStatusException; +import org.openecomp.policy.common.im.StateChangeNotifier; +import org.openecomp.policy.common.logging.flexlogger.FlexLogger; +import org.openecomp.policy.common.logging.flexlogger.Logger; + +public class StateManagementTest { + private static Logger logger = FlexLogger.getLogger(StateManagementTest.class); + + private static final String DEFAULT_DB_DRIVER = "org.h2.Driver"; + private static final String DEFAULT_DB_URL = "jdbc:h2:file:./sql/smTest"; + private static final String DEFAULT_DB_USER = "sa"; + private static final String DEFAULT_DB_PWD = ""; + + private static final String DB_DRIVER = "javax.persistence.jdbc.driver"; + private static final String DB_URL = "javax.persistence.jdbc.url"; + private static final String DB_USER = "javax.persistence.jdbc.user"; + private static final String DB_PWD = "javax.persistence.jdbc.password"; + // + + @BeforeClass + public static void setUpClass() throws Exception { + + } + + @AfterClass + public static void tearDownClass() throws Exception { + } + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } + + @Ignore + @Test + public void testJPA() throws Exception { + logger.info("\n\nlogger.infor StateManagementTest: Entering\n\n"); + String resourceName = "test_resource1"; + boolean standbyExceptionThrown = false; + + //These parameters are in a properties file + EntityManagerFactory emf = null; + try { + Properties myProp = new Properties(); + myProp.put(DB_DRIVER, DEFAULT_DB_DRIVER); + myProp.put(DB_URL, DEFAULT_DB_URL); + myProp.put(DB_USER, DEFAULT_DB_USER); + myProp.put(DB_PWD, DEFAULT_DB_PWD); + + //Create the data schema and entity manager factory + emf = Persistence.createEntityManagerFactory("schemaPU", myProp); + + StateManagement sm = new StateManagement(emf, resourceName); + System.out.println("\n\ntest lock()"); + displayState(resourceName, sm); + logger.info("\n??? test lock()"); + logger.info(resourceName + " before adminState = " + sm.getAdminState()); + logger.info(resourceName + " before opState = " + sm.getOpState()); + logger.info(resourceName + " before availStatus = " + sm.getAvailStatus()); + logger.info(resourceName + " before standbyStatus= " + sm.getStandbyStatus()); + sm.lock(); + System.out.println("\n\nafter lock()"); + displayState(resourceName, sm); + logger.info(resourceName + " after adminState = " + sm.getAdminState()); + logger.info(resourceName + " after opState = " + sm.getOpState()); + logger.info(resourceName + " after availStatus = " + sm.getAvailStatus()); + logger.info(resourceName + " after standbyStatus= " + sm.getStandbyStatus()); + + logger.info("\n??? test unlock()"); + sm.unlock(); + System.out.println("\n\nafter unlock()"); + displayState(resourceName, sm); + logger.info(resourceName + " adminState = " + sm.getAdminState()); + logger.info(resourceName + " opState = " + sm.getOpState()); + logger.info(resourceName + " availStatus = " + sm.getAvailStatus()); + logger.info(resourceName + " standbyStatus= " + sm.getStandbyStatus()); + + logger.info("\n??? test enableNotFailed()"); + sm.enableNotFailed(); + System.out.println("\n\nafter enableNotFailed()"); + displayState(resourceName, sm); + logger.info(resourceName + " adminState = " + sm.getAdminState()); + logger.info(resourceName + " opState = " + sm.getOpState()); + logger.info(resourceName + " availStatus = " + sm.getAvailStatus()); + logger.info(resourceName + " standbyStatus= " + sm.getStandbyStatus()); + + logger.info("\n??? test disableFailed()"); + sm.disableFailed(); + System.out.println("\n\nafter disableFailed()"); + displayState(resourceName, sm); + logger.info(resourceName + " adminState = " + sm.getAdminState()); + logger.info(resourceName + " opState = " + sm.getOpState()); + logger.info(resourceName + " availStatus = " + sm.getAvailStatus()); + logger.info(resourceName + " standbyStatus= " + sm.getStandbyStatus()); + + // P4 If promote() is called while either the opState is disabled or the adminState is locked, + // the standbystatus shall transition to coldstandby and a StandbyStatusException shall be thrown + logger.info("\n??? promote() test case P4"); + try { + sm.disableFailed(); + sm.lock(); + System.out.println("\n\nafter lock() and disableFailed"); + displayState(resourceName, sm); + logger.info(resourceName + " adminState = " + sm.getAdminState()); + logger.info(resourceName + " opState = " + sm.getOpState()); + logger.info(resourceName + " standbyStatus= " + sm.getStandbyStatus()); + sm.promote(); + System.out.println("\n\nafter promote"); + displayState(resourceName, sm); + } catch(StandbyStatusException ex) { + standbyExceptionThrown = true; + logger.info("StandbyStatusException thrown and catched"); + } catch(Exception ex) { + logger.info("??? Exception: " + ex.toString()); + } + assert(standbyExceptionThrown); + assert(sm.getStandbyStatus().equals(StateManagement.COLD_STANDBY)); + standbyExceptionThrown = false; + + // P3 If promote() is called while standbyStatus is coldstandby, the state shall not transition + // and a StandbyStatusException shall be thrown + logger.info("\n??? promote() test case P3"); + try { + logger.info(resourceName + " standbyStatus= " + sm.getStandbyStatus()); + sm.promote(); + } catch(StandbyStatusException ex) { + standbyExceptionThrown = true; + logger.info("StandbyStatusException thrown and catched"); + } catch(Exception ex) { + logger.info("??? Exception: " + ex.toString()); + } + assert(standbyExceptionThrown); + assert(sm.getStandbyStatus().equals(StateManagement.COLD_STANDBY)); + System.out.println("\n\nP3 after promote()"); + displayState(resourceName, sm); + standbyExceptionThrown = false; + + // P2 If promote() is called while the standbyStatus is null and the opState is enabled and adminState is unlocked, + // the state shall transition to providingservice + logger.info("\n??? promote() test case P2"); + resourceName = "test_resource2"; + StateManagement sm2 = new StateManagement(emf, resourceName); + sm2.enableNotFailed(); + sm2.unlock(); + System.out.println("\n\nafter sm2.enableNotFailed() and sm2.unlock()"); + displayState(resourceName, sm2); + logger.info(resourceName + " adminState = " + sm2.getAdminState()); + logger.info(resourceName + " opState = " + sm2.getOpState()); + logger.info(resourceName + " standbyStatus= " + sm2.getStandbyStatus()); + sm2.promote(); + System.out.println("\n\nP2 after sm2.promote"); + displayState(resourceName, sm2); + assert(sm2.getAdminState().equals(StateManagement.UNLOCKED)); + assert(sm2.getOpState().equals(StateManagement.ENABLED)); + assert(sm2.getStandbyStatus().equals(StateManagement.PROVIDING_SERVICE)); + + // P5 If promote() is called while standbyStatus is providingservice, no action is taken + logger.info("\n??? promote() test case P5"); + logger.info(resourceName + " standbyStatus= " + sm2.getStandbyStatus()); + sm2.promote(); + System.out.println("\n\nP5 after sm2.promote()"); + displayState(resourceName, sm2); + assert(sm2.getStandbyStatus().equals(StateManagement.PROVIDING_SERVICE)); + + // D1 If demote() is called while standbyStatus is providingservice, the state shall transition to hotstandby + logger.info("\n??? demote() test case D1"); + logger.info(resourceName + " standbyStatus= " + sm2.getStandbyStatus()); + sm2.demote(); + System.out.println("\n\nD1 after sm2.demote()"); + displayState(resourceName, sm2); + assert(sm2.getStandbyStatus().equals(StateManagement.HOT_STANDBY)); + + // D4 If demote() is called while standbyStatus is hotstandby, no action is taken + logger.info("\n??? demote() test case D4"); + logger.info(resourceName + " standbyStatus= " + sm2.getStandbyStatus()); + sm2.demote(); + System.out.println("\n\nD4 after sm2.demote()"); + displayState(resourceName, sm2); + assert(sm2.getStandbyStatus().equals(StateManagement.HOT_STANDBY)); + + // D3 If demote() is called while standbyStatus is null and adminState is locked or opState is disabled, + // the state shall transition to coldstandby + logger.info("\n??? demote() test case D3"); + resourceName = "test_resource3"; + StateManagement sm3 = new StateManagement(emf, resourceName); + sm3.lock(); + sm3.disableFailed(); + System.out.println("\n\nD3 after sm3.lock() and sm3.disableFailed()"); + displayState(resourceName, sm3); + logger.info(resourceName + " adminState = " + sm3.getAdminState()); + logger.info(resourceName + " opState = " + sm3.getOpState()); + logger.info(resourceName + " standbyStatus= " + sm3.getStandbyStatus()); + sm3.demote(); + System.out.println("\n\nD3 after sm3.demote()"); + displayState(resourceName, sm3); + assert(sm3.getStandbyStatus().equals(StateManagement.COLD_STANDBY)); + + // D5 If demote() is called while standbyStatus is coldstandby, no action is taken + logger.info("\n??? demote() test case D5"); + logger.info(resourceName + " standbyStatus= " + sm3.getStandbyStatus()); + sm3.demote(); + System.out.println("\n\nD5 after sm3.demote()"); + displayState(resourceName, sm3); + assert(sm3.getStandbyStatus().equals(StateManagement.COLD_STANDBY)); + + // D2 If demote() is called while standbyStatus is null and adminState is unlocked and opState is enabled, + // the state shall transition to hotstandby + logger.info("\n??? demote() test case D2"); + resourceName = "test_resource4"; + StateManagement sm4 = new StateManagement(emf, resourceName); + sm4.unlock(); + sm4.enableNotFailed(); + System.out.println("\n\nD2 after sm4.unlock() and sm4.enableNotFailed()"); + displayState(resourceName, sm4); + logger.info(resourceName + " adminState = " + sm4.getAdminState()); + logger.info(resourceName + " opState = " + sm4.getOpState()); + logger.info(resourceName + " standbyStatus= " + sm4.getStandbyStatus()); + sm4.demote(); + assert(sm4.getStandbyStatus().equals(StateManagement.HOT_STANDBY)); + + // P1 If promote() is called while standbyStatus is hotstandby, the state shall transition to providingservice. + logger.info("\n??? promote() test case P1"); + logger.info(resourceName + " standbyStatus= " + sm4.getStandbyStatus()); + sm4.promote(); + System.out.println("\n\nP1 after sm4.promote()"); + displayState(resourceName, sm4); + assert(sm4.getStandbyStatus().equals(StateManagement.PROVIDING_SERVICE)); + + // State change notification + logger.info("\n??? State change notification test case 1 - lock()"); + StateChangeNotifier stateChangeNotifier = new StateChangeNotifier(); + sm.addObserver(stateChangeNotifier); + sm.lock(); + + logger.info("\n??? State change notification test case 2 - unlock()"); + sm.unlock(); + + logger.info("\n??? State change notification test case 3 - enabled()"); + sm.enableNotFailed(); + + logger.info("\n??? State change notification test case 4 - disableFailed()"); + sm.disableFailed(); + + logger.info("\n??? State change notification test case 5 - demote()"); + sm.demote(); + + logger.info("\n??? State change notification test case 6 - promote()"); + try { + sm.promote(); + } catch(Exception ex) { + logger.info("Exception from promote(): " + ex.toString()); + } + + if (emf.isOpen()) { + emf.close(); + } + } catch(Exception ex) { + logger.error("Exception: " + ex.toString()); + } finally { + if (emf.isOpen()) { + emf.close(); + } + } + + logger.info("\n\nStateManagementTest: Exit\n\n"); + } + + private void displayState(String resourceName, StateManagement sm) + { + System.out.println("\nAdminState = " + sm.getAdminState() + + "\nOpState() = " + sm.getOpState() + + "\nAvailStatus = " + sm.getAvailStatus() + + "\nStandbyStatus = " + sm.getStandbyStatus() + + "\n"); + logger.info(resourceName + " adminState = " + sm.getAdminState()); + logger.info(resourceName + " opState = " + sm.getOpState()); + logger.info(resourceName + " availStatus = " + sm.getAvailStatus()); + logger.info(resourceName + " standbyStatus= " + sm.getStandbyStatus()); + } +} + diff --git a/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateTransitionTest.java b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateTransitionTest.java new file mode 100644 index 00000000..b0e6e18e --- /dev/null +++ b/integrity-monitor/src/test/java/org/openecomp/policy/common/im/test/StateTransitionTest.java @@ -0,0 +1,2188 @@ +/*- + * ============LICENSE_START======================================================= + * Integrity Monitor + * ================================================================================ + * 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.im.test; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; +import java.util.StringTokenizer; +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.EntityTransaction; +import javax.persistence.Persistence; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +//import org.apache.commons.logging.Log; +//import org.apache.commons.logging.LogFactory; + +import org.openecomp.policy.common.im.StateTransition; +import org.openecomp.policy.common.im.StateElement; +import org.openecomp.policy.common.im.StandbyStatusException; +import org.openecomp.policy.common.im.StateChangeNotifier; +import org.openecomp.policy.common.logging.flexlogger.FlexLogger; +import org.openecomp.policy.common.logging.flexlogger.Logger; + +public class StateTransitionTest { + private static Logger logger = FlexLogger.getLogger(StateTransitionTest.class); + + private static final String DEFAULT_DB_DRIVER = "org.h2.Driver"; + private static final String DEFAULT_DB_URL = "jdbc:h2:file:./sql/smTest"; + private static final String DEFAULT_DB_USER = "sa"; + private static final String DEFAULT_DB_PWD = ""; + + private static final String DB_DRIVER = "javax.persistence.jdbc.driver"; + private static final String DB_URL = "javax.persistence.jdbc.url"; + private static final String DB_USER = "javax.persistence.jdbc.user"; + private static final String DB_PWD = "javax.persistence.jdbc.password"; + // + + @BeforeClass + public static void setUpClass() throws Exception { + + } + + @AfterClass + public static void tearDownClass() throws Exception { + } + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } + + @Ignore + @Test + public void testJPA() throws Exception { + logger.info("\n\nlogger.infor StateTransitionTest: Entering\n\n"); + boolean standbyExceptionThrown = false; + + //These parameters are in a properties file + EntityManagerFactory emf = null; + try { + Properties myProp = new Properties(); + myProp.put(DB_DRIVER, DEFAULT_DB_DRIVER); + myProp.put(DB_URL, DEFAULT_DB_URL); + myProp.put(DB_USER, DEFAULT_DB_USER); + myProp.put(DB_PWD, DEFAULT_DB_PWD); + + logger.info("??? create a new StateTransition"); + StateTransition st = new StateTransition(); + + StateElement se = null; + try { + // bad test case + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "lock"); + // + logger.info("??? StateTransition testcase 1"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "lock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 2"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 3"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 4"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 5"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 6"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 7"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 8"); + se = st.getEndingState("unlocked", "enabled", "null", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 9"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 10"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 11"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 12"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 13"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 14"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 15"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 16"); + se = st.getEndingState("unlocked", "enabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 17"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 18"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 19"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 20"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 21"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 22"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 23"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 24"); + se = st.getEndingState("unlocked", "enabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 25"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 26"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 27"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 28"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 29"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 30"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 31"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 32"); + se = st.getEndingState("unlocked", "enabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 33"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 34"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 35"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 36"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 37"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 38"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 39"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 40"); + se = st.getEndingState("unlocked", "enabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 41"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 42"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 43"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 44"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 45"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 46"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 47"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 48"); + se = st.getEndingState("unlocked", "enabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 49"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 50"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 51"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 52"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 53"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 54"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 55"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 56"); + se = st.getEndingState("unlocked", "enabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 57"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 58"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 59"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 60"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 61"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 62"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 63"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 64"); + se = st.getEndingState("unlocked", "enabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 65"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 66"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 67"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 68"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 69"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 70"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 71"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 72"); + se = st.getEndingState("unlocked", "enabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 73"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 74"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 75"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 76"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 77"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 78"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 79"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 80"); + se = st.getEndingState("unlocked", "enabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 81"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 82"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 83"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 84"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 85"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 86"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 87"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 88"); + se = st.getEndingState("unlocked", "enabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 89"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 90"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 91"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 92"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 93"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 94"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 95"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 96"); + se = st.getEndingState("unlocked", "enabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 97"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 98"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 99"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 100"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 101"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 102"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 103"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 104"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 105"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 106"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 107"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 108"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 109"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 110"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 111"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 112"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 113"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 114"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 115"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 116"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 117"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 118"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 119"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 120"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 121"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 122"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 123"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 124"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 125"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 126"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 127"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 128"); + se = st.getEndingState("unlocked", "enabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 129"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 130"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 131"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 132"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 133"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 134"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 135"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 136"); + se = st.getEndingState("unlocked", "disabled", "null", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 137"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 138"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 139"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 140"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 141"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 142"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 143"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 144"); + se = st.getEndingState("unlocked", "disabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 145"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 146"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 147"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 148"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 149"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 150"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 151"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 152"); + se = st.getEndingState("unlocked", "disabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 153"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 154"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 155"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 156"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 157"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 158"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 159"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 160"); + se = st.getEndingState("unlocked", "disabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 161"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 162"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 163"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 164"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 165"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 166"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 167"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 168"); + se = st.getEndingState("unlocked", "disabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 169"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 170"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 171"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 172"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 173"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 174"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 175"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 176"); + se = st.getEndingState("unlocked", "disabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 177"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 178"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 179"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 180"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 181"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 182"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 183"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 184"); + se = st.getEndingState("unlocked", "disabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 185"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 186"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 187"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 188"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 189"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 190"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 191"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 192"); + se = st.getEndingState("unlocked", "disabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 193"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 194"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 195"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 196"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 197"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 198"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 199"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 200"); + se = st.getEndingState("unlocked", "disabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 201"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 202"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 203"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 204"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 205"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 206"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 207"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 208"); + se = st.getEndingState("unlocked", "disabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 209"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 210"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 211"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 212"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 213"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 214"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 215"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 216"); + se = st.getEndingState("unlocked", "disabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 217"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 218"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 219"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 220"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 221"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 222"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 223"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 224"); + se = st.getEndingState("unlocked", "disabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 225"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 226"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 227"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 228"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 229"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 230"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 231"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 232"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 233"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 234"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 235"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 236"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 237"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 238"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 239"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 240"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 241"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 242"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 243"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 244"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 245"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 246"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 247"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 248"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 249"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 250"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 251"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 252"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 253"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 254"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 255"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 256"); + se = st.getEndingState("unlocked", "disabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 257"); + se = st.getEndingState("locked", "enabled", "null", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 258"); + se = st.getEndingState("locked", "enabled", "null", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 259"); + se = st.getEndingState("locked", "enabled", "null", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 260"); + se = st.getEndingState("locked", "enabled", "null", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 261"); + se = st.getEndingState("locked", "enabled", "null", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 262"); + se = st.getEndingState("locked", "enabled", "null", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 263"); + se = st.getEndingState("locked", "enabled", "null", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 264"); + se = st.getEndingState("locked", "enabled", "null", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 265"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 266"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 267"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 268"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 269"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 270"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 271"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 272"); + se = st.getEndingState("locked", "enabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 273"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 274"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 275"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 276"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 277"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 278"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 279"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 280"); + se = st.getEndingState("locked", "enabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 281"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 282"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 283"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 284"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 285"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 286"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 287"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 288"); + se = st.getEndingState("locked", "enabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 289"); + se = st.getEndingState("locked", "enabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 290"); + se = st.getEndingState("locked", "enabled", "failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 291"); + se = st.getEndingState("locked", "enabled", "failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 292"); + se = st.getEndingState("locked", "enabled", "failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 293"); + se = st.getEndingState("locked", "enabled", "failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 294"); + se = st.getEndingState("locked", "enabled", "failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 295"); + se = st.getEndingState("locked", "enabled", "failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 296"); + se = st.getEndingState("locked", "enabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 297"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 298"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 299"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 300"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 301"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 302"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 303"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 304"); + se = st.getEndingState("locked", "enabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 305"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 306"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 307"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 308"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 309"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 310"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 311"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 312"); + se = st.getEndingState("locked", "enabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 313"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 314"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 315"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 316"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 317"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 318"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 319"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 320"); + se = st.getEndingState("locked", "enabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 321"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 322"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 323"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 324"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 325"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 326"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 327"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 328"); + se = st.getEndingState("locked", "enabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 329"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 330"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 331"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 332"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 333"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 334"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 335"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 336"); + se = st.getEndingState("locked", "enabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 337"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 338"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 339"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 340"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 341"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 342"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 343"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 344"); + se = st.getEndingState("locked", "enabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 345"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 346"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 347"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 348"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 349"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 350"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 351"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 352"); + se = st.getEndingState("locked", "enabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 353"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 354"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 355"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 356"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 357"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 358"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 359"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 360"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 361"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 362"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 363"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 364"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 365"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 366"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 367"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 368"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 369"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 370"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 371"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 372"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 373"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 374"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 375"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 376"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 377"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 378"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 379"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 380"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 381"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 382"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 383"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 384"); + se = st.getEndingState("locked", "enabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 385"); + se = st.getEndingState("locked", "disabled", "null", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 386"); + se = st.getEndingState("locked", "disabled", "null", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 387"); + se = st.getEndingState("locked", "disabled", "null", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 388"); + se = st.getEndingState("locked", "disabled", "null", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 389"); + se = st.getEndingState("locked", "disabled", "null", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 390"); + se = st.getEndingState("locked", "disabled", "null", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 391"); + se = st.getEndingState("locked", "disabled", "null", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 392"); + se = st.getEndingState("locked", "disabled", "null", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 393"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 394"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 395"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 396"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 397"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 398"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 399"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 400"); + se = st.getEndingState("locked", "disabled", "null", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 401"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 402"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 403"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 404"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 405"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 406"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 407"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 408"); + se = st.getEndingState("locked", "disabled", "null", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 409"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 410"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 411"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 412"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 413"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 414"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 415"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 416"); + se = st.getEndingState("locked", "disabled", "null", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 417"); + se = st.getEndingState("locked", "disabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 418"); + se = st.getEndingState("locked", "disabled", "failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 419"); + se = st.getEndingState("locked", "disabled", "failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 420"); + se = st.getEndingState("locked", "disabled", "failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 421"); + se = st.getEndingState("locked", "disabled", "failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 422"); + se = st.getEndingState("locked", "disabled", "failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 423"); + se = st.getEndingState("locked", "disabled", "failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 424"); + se = st.getEndingState("locked", "disabled", "failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 425"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 426"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 427"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 428"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 429"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 430"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 431"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 432"); + se = st.getEndingState("locked", "disabled", "failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 433"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 434"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 435"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 436"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 437"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 438"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 439"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 440"); + se = st.getEndingState("locked", "disabled", "failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 441"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 442"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 443"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 444"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 445"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 446"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 447"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 448"); + se = st.getEndingState("locked", "disabled", "failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 449"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 450"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 451"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 452"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 453"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 454"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 455"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 456"); + se = st.getEndingState("locked", "disabled", "dependency", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 457"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 458"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 459"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 460"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 461"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 462"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 463"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 464"); + se = st.getEndingState("locked", "disabled", "dependency", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 465"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 466"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 467"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 468"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 469"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 470"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 471"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 472"); + se = st.getEndingState("locked", "disabled", "dependency", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 473"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 474"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 475"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 476"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 477"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 478"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 479"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 480"); + se = st.getEndingState("locked", "disabled", "dependency", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 481"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 482"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 483"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 484"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 485"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 486"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 487"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 488"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "null", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 489"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 490"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 491"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 492"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 493"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 494"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 495"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 496"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "coldstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 497"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 498"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 499"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 500"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 501"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 502"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 503"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 504"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "hotstandby", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 505"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 506"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "unlock"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 507"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "disableFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 508"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "enableNotFailed"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 509"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "disableDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 510"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "enableNoDependency"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 511"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "promote"); + if (se != null) displayEndingState(se); + + logger.info("??? StateTransition testcase 512"); + se = st.getEndingState("locked", "disabled", "dependency,failed", "providingservice", "demote"); + if (se != null) displayEndingState(se); + + } catch (Exception ex) { + logger.error("EndingState NOT found"); + throw new Exception("EndingState NOT found. " + ex); + } + + //if (emf.isOpen()) { + //emf.close(); + //} + } catch(Exception ex) { + logger.error("Exception: " + ex.toString()); + throw new Exception("Failure getting ending state. " + ex ); + } finally { + if (emf != null && emf.isOpen()) { + emf.close(); + } + } + + logger.info("\n\nStateTransitionTest: Exit\n\n"); + } + + private void displayEndingState(StateElement se) + { + String endingStandbyStatus = se.getEndingStandbyStatus(); + if (endingStandbyStatus != null) { + endingStandbyStatus.replace(".", ","); + } + logger.info("EndingAdminState = [" + se.getEndingAdminState() +"]"); + logger.info("EndingOpState = [" + se.getEndingOpState() +"]"); + logger.info("EndingAvailStatus = [" + se.getEndingAvailStatus() +"]"); + logger.info("EndingStandbyStatus= [" + endingStandbyStatus +"]"); + logger.info("Exception = [" + se.getException() +"]"); + } +} \ No newline at end of file -- cgit 1.2.3-korg