path: root/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTest.java

/*-
 * ============LICENSE_START=======================================================
 * ONAP-PAP-REST
 * ================================================================================
 * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */

package org.onap.policy.pap.xacml.rest.components;

import static org.junit.Assert.fail;
import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.util.XACMLProperties;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.PersistenceException;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.rest.dao.PolicyDBException;
import org.onap.policy.rest.jpa.DatabaseLockEntity;
import org.onap.policy.rest.jpa.GroupEntity;
import org.onap.policy.rest.jpa.PdpEntity;
import org.onap.policy.rest.jpa.PolicyEntity;
import org.onap.policy.rest.jpa.UserInfo;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.std.pap.StdEngine;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;

public class PolicyDBDaoTest {
    private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);

    static PolicyDBDaoTestClass d;
    static PolicyDBDao dbd;
    static PolicyDBDao dbd2;
    private static Path repository;
    static StdEngine stdEngine = null;
    static SessionFactory sessionFactory = null;

    @BeforeClass
    public static void init() throws PAPException, IOException {
        System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
        try {
            sessionFactory = setupH2DbDaoImpl("testdbdao");
            dbd = PolicyDBDao.getPolicyDBDaoInstance();
            dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
        } catch (Exception e) {
            Assert.fail();
        }

        d = PolicyDBDao.getPolicyDBDaoTestClass();
        PolicyDBDao.setJunit(true);
        repository = Paths.get("src/test/resources/pdps");
        stdEngine = new StdEngine(repository);
        dbd.setPapEngine(stdEngine);
    }

    @After
    public void cleanUp() {
        try {
            FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
        } catch (IOException e) {
            // could not delete
        }
    }

    public static SessionFactory setupH2DbDaoImpl(String dbName) {
        setUpAuditDb();

        System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("org.h2.Driver");
        dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
        dataSource.setUsername("sa");
        dataSource.setPassword("");
        LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
        sessionBuilder.scanPackages("org.onap.*");

        Properties properties = new Properties();
        properties.put("hibernate.show_sql", "false");
        properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
        properties.put("hibernate.hbm2ddl.auto", "create-drop");

        sessionBuilder.addProperties(properties);
        SessionFactory sessionFac = sessionBuilder.buildSessionFactory();

        new PolicyDBDao(sessionFac);
        PolicyDbDaoTransactionInstance.setJunit(true);
        new PolicyDbDaoTransactionInstance(sessionFac);
        CommonClassDaoImpl.setSessionfactory(sessionFac);
        new DataToNotifyPdp(new CommonClassDaoImpl());
        PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());

        DatabaseLockEntity lock = null;
        Session session = sessionFac.openSession();
        session.getTransaction().begin();
        lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
        if (lock == null) {
            lock = new DatabaseLockEntity();
            lock.setKey(1);
            session.persist(lock);
            session.flush();
        }
        session.getTransaction().commit();
        session.close();

        UserInfo user = new UserInfo();
        user.setUserLoginId("API");
        user.setUserName("API");
        Session session2 = sessionFac.openSession();
        session2.getTransaction().begin();
        session2.persist(user);

        session2.getTransaction().commit();
        session2.close();

        return sessionFac;
    }


    private static void setUpAuditDb() {
        Properties properties = new Properties();
        properties.put(XACMLRestProperties.PROP_PAP_DB_DRIVER,"org.h2.Driver");
        properties.put(XACMLRestProperties.PROP_PAP_DB_URL, "jdbc:h2:file:./sql/xacmlTest");
        properties.put(XACMLRestProperties.PROP_PAP_DB_USER, "sa");
        properties.put(XACMLRestProperties.PROP_PAP_DB_PASSWORD, "");

        // create the DB and then close it
        Persistence.createEntityManagerFactory("testPapPU", properties).close();
    }

    @Test
    public void testGetConfigFile() {
        PolicyRestAdapter pra = new PolicyRestAdapter();
        pra.setConfigType(ConfigPolicy.JSON_CONFIG);
        String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
        Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
        // yes, we can do action files too even though they don't have configs
        configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
        Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
    }

    @Test
    public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
        String policyName = "com.Decision_testname.1.xml";
        String[] expectedNameAndVersion = new String[2];
        expectedNameAndVersion[0] = "com.Decision_testname";
        expectedNameAndVersion[1] = "1";
        String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
        Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
    }

    @Test
    public void getNameScopeAndVersionFromPdpPolicyTest() {
        String fileName = "com.Decision_testname.1.xml";
        String[] expectedArray = new String[3];
        expectedArray[0] = "Decision_testname.1.xml";
        expectedArray[2] = "1";
        expectedArray[1] = "com";

        String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
        Assert.assertArrayEquals(expectedArray, returnArray);
    }

    @Test
    public void getPdpPolicyNameTest() {
        String name = "Decision_testname.1.json";
        String scope = "com";
        String expectedFinalname = "com.Decision_testname.1.xml";

        String finalname = d.getPdpPolicyName(name, scope);
        Assert.assertEquals(expectedFinalname, finalname);
    }

    @Test
    public void getPolicySubFileTest() {
        String name = "Config_testname.1.json";
        String subFileType = "Config";
        HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);

        Path path = handle.getPolicySubFile(name, subFileType);
        Assert.assertNull(path);
    }

    @Test
    public void createFromPolicyObject() {
        Policy policyObject = new ConfigPolicy();
        policyObject.policyAdapter = new PolicyRestAdapter();
        policyObject.policyAdapter.setConfigName("testpolicy1");
        policyObject.policyAdapter.setPolicyDescription("my description");
        policyObject.policyAdapter.setConfigBodyData("this is my test config file");
        policyObject.policyAdapter.setPolicyName("SampleTest1206");
        policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
        policyObject.policyAdapter.setPolicyType("Config");
        policyObject.policyAdapter.setDomainDir("com");
        policyObject.policyAdapter.setVersion("1");
        policyObject.policyAdapter.setHighestVersion(1);
        PolicyType policyTypeObject = new PolicyType();
        policyObject.policyAdapter.setPolicyData(policyTypeObject);
        ClassLoader classLoader = getClass().getClassLoader();
        PolicyType policyConfig = new PolicyType();
        policyConfig.setVersion("1");
        policyConfig.setPolicyId("");
        policyConfig.setTarget(new TargetType());
        policyObject.policyAdapter.setData(policyConfig);
        try {
            policyObject.policyAdapter
                    .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
        } catch (Exception e2) {
            fail();
        }

        PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
        try {
            transaction.createPolicy(policyObject, "testuser1");
            transaction.commitTransaction();
        } catch (Exception e) {
            transaction.rollbackTransaction();
            Assert.fail();
        }

        Session session = sessionFactory.openSession();
        session.getTransaction().begin();
        Query policyQuery =
                session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");

        policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
        policyQuery.setParameter("scope", "com");

        List<?> policyQueryList = policyQuery.list();
        PolicyEntity result = null;
        try {
            result = (PolicyEntity) policyQueryList.get(0);
        } catch (Exception e) {
            logger.error("Exception Occured " + e);
            Assert.fail();
        }
        session.getTransaction().commit();
        session.close();

        String expectedData;
        try {
            expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
        } catch (IOException e1) {
            expectedData = "";
        }
        Assert.assertEquals(expectedData, result.getPolicyData());
        result = null;

        Assert.assertFalse(transaction.isTransactionOpen());
    }

    @Test
    public void groupTransactions() {
        PolicyDBDaoTransaction group = dbd.getNewTransaction();
        String groupName = "test group 1";
        try {
            group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
                    "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }
        Session session = sessionFactory.openSession();
        session.getTransaction().begin();
        Query getGroup =
                session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
        getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
        getGroup.setParameter("deleted", false);
        List<?> groups = getGroup.list();
        GroupEntity groupEntity = (GroupEntity) groups.get(0);
        Assert.assertEquals(groupName, groupEntity.getgroupName());
        Assert.assertEquals("this is a test group", groupEntity.getDescription());
        session.getTransaction().commit();
        session.close();

        group = dbd.getNewTransaction();
        try {
            OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
            group.deleteGroup(groupToDelete, null, "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }
        Session session2 = sessionFactory.openSession();
        session2.getTransaction().begin();
        Query getGroup2 =
                session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
        getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
        getGroup2.setParameter("deleted", false);
        List<?> groups2 = getGroup2.list();
        groups2 = getGroup2.list();
        if (groups2.size() != 0) {
            System.out.println("Group size: " + groups2.size());
            Assert.fail();
        }
        session2.getTransaction().commit();
        session2.close();


        // add a pdp to a group
        group = dbd.getNewTransaction();
        try {
            group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        group = dbd.getNewTransaction();
        try {
            group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary",
                    "the main pdp", 3232, "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        Session session3 = sessionFactory.openSession();
        session3.getTransaction().begin();
        Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
        getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
        getPdp.setParameter("deleted", false);
        List<?> pdps = getPdp.list();
        if (pdps.size() != 1) {
            System.out.println("Group size: " + pdps.size());
            Assert.fail();
        }
        PdpEntity pdp = (PdpEntity) pdps.get(0);
        Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
        Assert.assertEquals(pdp.getPdpName(), "primary");
        session3.getTransaction().commit();
        session3.close();


        group = dbd.getNewTransaction();
        try {
            group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        Session session4 = sessionFactory.openSession();
        session4.getTransaction().begin();
        Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
        getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
        getPdp2.setParameter("deleted", false);
        List<?> pdps2 = getPdp2.list();
        if (pdps2.size() != 0) {
            System.out.println("Group size: " + pdps2.size());
            Assert.fail();
        }

        session4.getTransaction().commit();
        session4.close();

        // add some pdps to groups
        group = dbd.getNewTransaction();
        try {
            group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }
        group = dbd.getNewTransaction();
        try {
            group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        group = dbd.getNewTransaction();
        try {
            group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
                    "the main pdp", 3232, "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }
        group = dbd.getNewTransaction();
        try {
            group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
                    "secondary", "the second pdp", 3233, "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        Session session5 = sessionFactory.openSession();
        session5.getTransaction().begin();
        Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
        getPdp3.setParameter("deleted", false);
        List<?> pdps3 = getPdp3.list();
        for (Object obj : pdps3) {
            Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
        }

        session5.getTransaction().commit();
        session5.close();


        group = dbd.getNewTransaction();
        try {
            OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), Paths.get("/"));
            OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
            group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        Session session6 = sessionFactory.openSession();
        session6.getTransaction().begin();
        Query getGroup3 =
                session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
        getGroup3.setParameter("groupId", "testgroup1");
        getGroup3.setParameter("deleted", false);
        List<?> groups3 = getGroup3.list();
        if (groups3.size() != 0) {
            System.out.println("Group size: " + groups3.size());
            Assert.fail();
        }

        session6.getTransaction().commit();
        session6.close();

        Session session7 = sessionFactory.openSession();
        session7.getTransaction().begin();
        Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
        getPdp4.setParameter("deleted", false);
        List<?> pdps4 = getPdp4.list();
        for (Object obj : pdps4) {
            Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getgroupName());
        }

        session7.getTransaction().commit();
        session7.close();


        group = dbd.getNewTransaction();
        try {
            OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
            OnapPDPGroup groupToMoveTo = null;
            group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
            group.commitTransaction();
            Assert.fail();
        } catch (PolicyDBException pe) {
            // good, can't delete group with pdps
            group.rollbackTransaction();
        } catch (Exception e) {
            group.rollbackTransaction();
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        // update group
        OnapPDPGroup pdpGroup =
                new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
        group = dbd.getNewTransaction();
        try {
            group.updateGroup(pdpGroup, "testuser", "testuser");
            group.commitTransaction();
        } catch (Exception e) {
            logger.error("Exception Occured" + e);
            group.rollbackTransaction();
            Assert.fail();
        }

        Session session8 = sessionFactory.openSession();
        session8.getTransaction().begin();
        Query getGroup4 =
                session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
        getGroup4.setParameter("groupId", "newtestgroup2");
        getGroup4.setParameter("deleted", false);
        List<?> groups4 = getGroup4.list();
        if (groups4.size() != 1) {
            System.out.println("Group size: " + groups4.size());
            Assert.fail();
        }

        session8.getTransaction().commit();
        session8.close();

        Session session9 = sessionFactory.openSession();
        session9.getTransaction().begin();
        Query getGroup5 =
                session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
        getGroup5.setParameter("groupId", "testgroup2");
        getGroup5.setParameter("deleted", false);
        List<?> groups5 = getGroup5.list();
        if (groups5.size() != 0) {
            System.out.println("Group size: " + groups5.size());
            Assert.fail();
        }

        session9.getTransaction().commit();
        session9.close();
    }

    @Ignore
    @Test
    public void threadingStabilityTest() {
        if (logger.isDebugEnabled()) {
            logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
                    + "******************************\n\n");
        }

        PolicyDBDaoTransaction t = dbd.getNewTransaction();
        Assert.assertTrue(t.isTransactionOpen());
        try {
            // Add 1000 ms to the timeout just to be sure it actually times out
            int sleepTime =
                    Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
            if (logger.isDebugEnabled()) {
                Date date = new java.util.Date();
                logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   sleepTime =  " + sleepTime
                        + "\n   TimeStamp = " + date.getTime() + "\n\n");
            }
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            logger.error("Exception Occured" + e);
        }
        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug(
                    "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertFalse(t.isTransactionOpen() = "
                            + t.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
        Assert.assertFalse(t.isTransactionOpen());


        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   a = dbd.getNewTransaction() "
                    + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
        PolicyDBDaoTransaction a = dbd.getNewTransaction();
        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug(
                    "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(a.isTransactionOpen() = "
                            + a.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
        Assert.assertTrue(a.isTransactionOpen());

        try {
            // Add 1000 ms to the timeout just to be sure it actually times out
            int sleepTime =
                    Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
            if (logger.isDebugEnabled()) {
                Date date = new java.util.Date();
                logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   sleepTime =  " + sleepTime
                        + "\n   TimeStamp = " + date.getTime() + "\n\n");
            }
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            logger.error("Exception Occured" + e);
        }
        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   b = dbd.getNewTransaction() "
                    + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
        PolicyDBDaoTransaction b = dbd.getNewTransaction();
        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug(
                    "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertFalse(a.isTransactionOpen() = "
                            + a.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
        Assert.assertFalse(a.isTransactionOpen());
        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug(
                    "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(b.isTransactionOpen() = "
                            + b.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
        Assert.assertTrue(b.isTransactionOpen());
        b.close();



        // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
        System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT, "1000");
        // And let's lengthen the transaction timeout to 5000 ms
        System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
        // get a transacton
        PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug(
                    "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(t1.isTransactionOpen() = "
                            + t1.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
        Assert.assertTrue(t1.isTransactionOpen());
        // while it is open, get another from a different DB Dao so it will not collide on the synchronized
        // code segment
        // but will collide at the DB. Remember that the wait time is only 1000 ms
        try {
            // Now the 2nd transaction has a wait timeout in 1000 ms
            PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
            /*
             * Give it plenty of time to time out the second transaction It will actually hang right here until
             * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
             * sloppy so, I have given this plenty of leeway.
             */

            if (logger.isDebugEnabled()) {
                Date date = new java.util.Date();
                logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Thread.sleep(3000)"
                        + "\n   TimeStamp = " + date.getTime() + "\n\n");
            }
            Thread.sleep(3000);
            if (logger.isDebugEnabled()) {
                Date date = new java.util.Date();
                logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
                        + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
                        + "\n   Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
                        + "\n   TimeStamp = " + date.getTime() + "\n\n");
            }
            // Assert.assertTrue(t1.isTransactionOpen());
            // Assert.assertFalse(t2.isTransactionOpen());

            Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
        } catch (PersistenceException e) {
            // success
            if (logger.isDebugEnabled()) {
                Date date = new java.util.Date();
                logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
                        + "\n   SUCCESS! Transaction Wait Timeout worked!" + "\n   Caught PersistenceException = " + e
                        + "\n   TimeStamp = " + date.getTime() + "\n\n");
            }
        } catch (Exception e) {
            // failure due to some other reason
            if (logger.isDebugEnabled()) {
                Date date = new java.util.Date();
                logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n   Caught Exception = " + e
                        + "\n   TimeStamp = " + date.getTime() + "\n\n");
            }
            logger.error("Exception Occured" + e);
            Assert.fail();
        }

        if (logger.isDebugEnabled()) {
            Date date = new java.util.Date();
            logger.debug("\n\nthreadingStabilityTest() exit" + "\n   TimeStamp = " + date.getTime() + "\n\n");
        }
    }

}