* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
* ================================================================================
* 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.
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 javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
+import java.util.Properties;
import javax.persistence.Persistence;
import javax.persistence.PersistenceException;
-import javax.persistence.Query;
+
+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.apache.commons.logging.Log;
-//import org.apache.commons.logging.LogFactory;
-import org.junit.Before;
+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.components.PolicyDBDao.PolicyDBDaoTestClass;
-import org.onap.policy.rest.XACMLRestProperties;
+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.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.onap.policy.xacml.util.XACMLPolicyWriter;
+import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
-import com.att.research.xacml.util.XACMLProperties;
+public class PolicyDBDaoTest {
+ private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
-import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
+ static PolicyDbDaoTestClass d;
+ static PolicyDbDao dbd;
+ static PolicyDbDao dbd2;
+ private static Path repository;
+ static StdEngine stdEngine = null;
+ static SessionFactory sessionFactory = null;
-public class PolicyDBDaoTest {
+ @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();
+ }
- private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
-
- PolicyDBDaoTestClass d;
- PolicyDBDao dbd;
- PolicyDBDao dbd2;
- EntityManagerFactory emf;
- @Before
- public void init(){
- System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME,"src/test/resources/xacml.pap.properties");
- emf = Persistence.createEntityManagerFactory("testPapPU");
- EntityManager em = emf.createEntityManager();
- em.getTransaction().begin();
- try{
- em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
- em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
- em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
- em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
- em.createQuery("DELETE FROM PdpEntity").executeUpdate();
- em.createQuery("DELETE FROM GroupEntity").executeUpdate();
-
- em.getTransaction().commit();
- } catch(Exception e){
- logger.error("Exception Occured"+e);
- em.getTransaction().rollback();
- }
- em.close();
- try {
- dbd = PolicyDBDao.getPolicyDBDaoInstance(emf);
- dbd2 = PolicyDBDao.getPolicyDBDaoInstance(emf);
- } catch (Exception e) {
- //logger.error("Exception Occured"+e);
- Assert.fail();
- }
-
- d = PolicyDBDao.getPolicyDBDaoTestClass();
- }
-
- @After
- public void cleanUp(){
- EntityManager em = emf.createEntityManager();
- em.getTransaction().begin();
- try{
- em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
- em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
- em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
- em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
- em.createQuery("DELETE FROM PdpEntity").executeUpdate();
- em.createQuery("DELETE FROM GroupEntity").executeUpdate();
-
- em.getTransaction().commit();
- } catch(Exception e){
- em.getTransaction().rollback();
- }
- em.close();
- try {
- FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
- } catch (IOException e) {
- //could not delete
- }
-
- }
-
- @Test
- public void computeScopeTest(){
- Assert.assertEquals("com",d.computeScope("C:\\Users\\testuser\\admin\\repo\\com\\", "C:\\Users\\testuser\\admin\\repo"));
- Assert.assertEquals("org.onap.policy",d.computeScope("/Users/testuser/admin/repo/org.onap.policy", "/Users/testuser/admin/repo"));
- }
- @Test
- public void getConfigFileTest(){
- 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);
- }
-
- @Ignore
- @Test
- public void createFromPolicyObject(){
- String workspaceDir = "src/test/resources/";
- File parentPath = new File(workspaceDir+"/com");
- Policy policyObject = new ConfigPolicy();
- policyObject.policyAdapter = new PolicyRestAdapter();
- policyObject.policyAdapter.setConfigName("testpolicy1");
- policyObject.policyAdapter.setParentPath(parentPath.getAbsolutePath());
- policyObject.policyAdapter.setPolicyDescription("my description");
- policyObject.policyAdapter.setConfigBodyData("this is my test config file");
- policyObject.policyAdapter.setPolicyName("testpolicy1");
- policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
- policyObject.policyAdapter.setPolicyType("Config");
- policyObject.policyAdapter.setDomainDir("org.onap");
- PolicyType policyTypeObject = new PolicyType();
- policyObject.policyAdapter.setPolicyData(policyTypeObject);
- PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
- try{
- transaction.createPolicy(policyObject, "testuser1");
- transaction.commitTransaction();
- } catch(Exception e){
- transaction.rollbackTransaction();
- Assert.fail();
- }
-
- EntityManager getData = emf.createEntityManager();
- Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
- getDataQuery.setParameter("scope", "org.onap");
- getDataQuery.setParameter("name","Config_testpolicy1.xml");
- PolicyEntity result = null;
- try{
- result = (PolicyEntity)getDataQuery.getSingleResult();
- } catch(Exception e){
- logger.error("Exception Occured"+e);
- Assert.fail();
- }
- String expectedData;
- try {
- expectedData = IOUtils.toString(XACMLPolicyWriter.getXmlAsInputStream(policyTypeObject));
- } catch (IOException e1) {
- expectedData = "";
- }
- Assert.assertEquals(expectedData, result.getPolicyData());
- getData.close();
- result = null;
- File policyFile = new File(workspaceDir+"/org/onap/Config_testpolicy1.xml");
- try{
- transaction = dbd.getNewTransaction();
- transaction.deletePolicy(policyFile.getAbsolutePath());
- } catch(Exception e){
- logger.error("Exception Occured"+e);
- Assert.fail();
- }
- Assert.assertTrue(transaction.isTransactionOpen());
- try{
- transaction.deletePolicy(policyFile.getAbsolutePath());
- Assert.fail();
- } catch(IllegalStateException e){
- //pass
- } catch(Exception e){
- Assert.fail();
- }
- transaction.commitTransaction();
- Assert.assertFalse(transaction.isTransactionOpen());
- try{
- transaction = dbd.getNewTransaction();
- transaction.deletePolicy(policyFile.getAbsolutePath());
- } catch(Exception e){
- logger.error("Exception Occured"+e);
- Assert.fail();
- }
- //Assert.assertFalse(transaction.isTransactionOpen());
- transaction.commitTransaction();
- }
-
- @Ignore
- @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();
- }
- EntityManager em = emf.createEntityManager();
- Query getGroup = em.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.getResultList();
- if(groups.size() != 1){
- Assert.fail();
- }
- GroupEntity groupEntity = (GroupEntity)groups.get(0);
- em.close();
- Assert.assertEquals(groupName, groupEntity.getgroupName());
- Assert.assertEquals("this is a test group", groupEntity.getDescription());
- 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();
- }
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 0){
- System.out.println("Group size: "+groups.size());
- Assert.fail();
- }
- em.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();
- }
- em = emf.createEntityManager();
- Query getPdp = em.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.getResultList();
- 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");
- em.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();
- }
- em = emf.createEntityManager();
- getPdp = em.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);
- pdps = getPdp.getResultList();
- if(pdps.size() != 0){
- System.out.println("Group size: "+pdps.size());
- Assert.fail();
- }
- em.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();
- }
- em = emf.createEntityManager();
- getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
- getPdp.setParameter("deleted", false);
- pdps = getPdp.getResultList();
- for(Object o : pdps){
- Assert.assertEquals("testgroup1",((PdpEntity)o).getGroup().getgroupName());
- }
- em.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();
- }
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", "testgroup1");
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 0){
- System.out.println("Group size: "+groups.size());
- Assert.fail();
- }
- em.close();
-
- em = emf.createEntityManager();
- getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
- getPdp.setParameter("deleted", false);
- pdps = getPdp.getResultList();
- for(Object o : pdps){
- Assert.assertEquals("testgroup2",((PdpEntity)o).getGroup().getgroupName());
- }
- em.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();
- }
-
-
- //add policy to group
-
- //update group
- OnapPDPGroup pdpGroup = new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
- group = dbd.getNewTransaction();
- try{
- group.updateGroup(pdpGroup, "testuser");
- group.commitTransaction();
- }catch (Exception e){
- logger.error("Exception Occured"+e);
- group.rollbackTransaction();
- Assert.fail();
- }
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", "newtestgroup2");
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 1){
- System.out.println("Group size: "+groups.size());
- Assert.fail();
- }
- em.close();
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", "testgroup2");
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 0){
- System.out.println("Group size: "+groups.size());
- Assert.fail();
- }
- em.close();
- }
-
- @Test
- public void encryptionTest(){
- try {
- String encr = d.encryptPassword("testpassword");
- System.out.println("original password: "+"testpassword");
- System.out.println("Encrypted password: "+encr);
- String decr = d.decryptPassword(encr);
- System.out.println("Decrypted password: "+decr);
- Assert.assertEquals("testpassword", decr);
- } catch (Exception e) {
- logger.error("Exception Occured"+e);
- Assert.fail();
- }
-
- }
- @Test
- public void getDescriptionFromXacmlTest(){
- String myTestDesc = "hello this is a test";
- String desc = d.getDescriptionFromXacml("<Description>"+myTestDesc+"</Description>");
- Assert.assertEquals(myTestDesc, desc);
- }
- @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");
- }
- }
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ }
}