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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.xacml.rest.components;
  22
  23 import static org.junit.Assert.fail;
  24 import com.att.research.xacml.api.pap.PAPException;
  25 import com.att.research.xacml.util.XACMLProperties;
  26 import java.io.File;
  27 import java.io.IOException;
  28 import java.nio.file.Path;
  29 import java.nio.file.Paths;
  30 import java.util.Date;
  31 import java.util.List;
  32 import java.util.Properties;
  33 import javax.persistence.PersistenceException;
  34 import org.apache.commons.io.FileUtils;
  35 import org.apache.commons.io.IOUtils;
  36 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
  37 import org.hibernate.Query;
  38 import org.hibernate.Session;
  39 import org.hibernate.SessionFactory;
  40 import org.junit.After;
  41 import org.junit.Assert;
  42 import org.junit.BeforeClass;
  43 import org.junit.Ignore;
  44 import org.junit.Test;
  45 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  46 import org.onap.policy.common.logging.flexlogger.Logger;
  47 import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
  48 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
  49 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
  50 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
  51 import org.onap.policy.rest.XACMLRestProperties;
  52 import org.onap.policy.rest.adapter.PolicyRestAdapter;
  53 import org.onap.policy.rest.dao.PolicyDBException;
  54 import org.onap.policy.rest.jpa.DatabaseLockEntity;
  55 import org.onap.policy.rest.jpa.GroupEntity;
  56 import org.onap.policy.rest.jpa.PdpEntity;
  57 import org.onap.policy.rest.jpa.PolicyEntity;
  58 import org.onap.policy.rest.jpa.UserInfo;
  59 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
  60 import org.onap.policy.xacml.std.pap.StdEngine;
  61 import org.onap.policy.xacml.std.pap.StdPDPGroup;
  62 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
  63 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
  64 import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
  65
  66 public class PolicyDBDaoTest {
  67     private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
  68
  69     static PolicyDBDaoTestClass d;
  70     static PolicyDBDao dbd;
  71     static PolicyDBDao dbd2;
  72     private static Path repository;
  73     static StdEngine stdEngine = null;
  74     static SessionFactory sessionFactory = null;
  75
  76     @BeforeClass
  77     public static void init() throws PAPException, IOException {
  78         System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
  79         try {
  80             sessionFactory = setupH2DbDaoImpl("testdbdao");
  81             dbd = PolicyDBDao.getPolicyDBDaoInstance();
  82             dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
  83         } catch (Exception e) {
  84             Assert.fail();
  85         }
  86
  87         d = PolicyDBDao.getPolicyDBDaoTestClass();
  88         PolicyDBDao.setJunit(true);
  89         repository = Paths.get("src/test/resources/pdps");
  90         stdEngine = new StdEngine(repository);
  91         dbd.setPapEngine(stdEngine);
  92     }
  93
  94     @After
  95     public void cleanUp() {
  96         try {
  97             FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
  98         } catch (IOException e) {
  99             // could not delete
 100         }
 101     }
 102
 103     public static SessionFactory setupH2DbDaoImpl(String dbName) {
 104         System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
 105         BasicDataSource dataSource = new BasicDataSource();
 106         dataSource.setDriverClassName("org.h2.Driver");
 107         dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
 108         dataSource.setUsername("sa");
 109         dataSource.setPassword("");
 110         LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
 111         sessionBuilder.scanPackages("org.onap.*");
 112
 113         Properties properties = new Properties();
 114         properties.put("hibernate.show_sql", "false");
 115         properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
 116         properties.put("hibernate.hbm2ddl.auto", "create-drop");
 117
 118         sessionBuilder.addProperties(properties);
 119         SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
 120
 121         new PolicyDBDao(sessionFac);
 122         new PolicyDbDaoTransactionInstance(sessionFac).isJunit = true;
 123         CommonClassDaoImpl.setSessionfactory(sessionFac);
 124         new DataToNotifyPdp(new CommonClassDaoImpl());
 125         PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
 126
 127         DatabaseLockEntity lock = null;
 128         Session session = sessionFac.openSession();
 129         session.getTransaction().begin();
 130         lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
 131         if (lock == null) {
 132             lock = new DatabaseLockEntity();
 133             lock.setKey(1);
 134             session.persist(lock);
 135             session.flush();
 136         }
 137         session.getTransaction().commit();
 138         session.close();
 139
 140         UserInfo user = new UserInfo();
 141         user.setUserLoginId("API");
 142         user.setUserName("API");
 143         Session session2 = sessionFac.openSession();
 144         session2.getTransaction().begin();
 145         session2.persist(user);
 146
 147         session2.getTransaction().commit();
 148         session2.close();
 149
 150         return sessionFac;
 151     }
 152
 153
 154     @Test
 155     public void testGetConfigFile() {
 156         PolicyRestAdapter pra = new PolicyRestAdapter();
 157         pra.setConfigType(ConfigPolicy.JSON_CONFIG);
 158         String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
 159         Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
 160         // yes, we can do action files too even though they don't have configs
 161         configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
 162         Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
 163     }
 164
 165     @Test
 166     public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
 167         String policyName = "com.Decision_testname.1.xml";
 168         String[] expectedNameAndVersion = new String[2];
 169         expectedNameAndVersion[0] = "com.Decision_testname";
 170         expectedNameAndVersion[1] = "1";
 171         String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
 172         Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
 173     }
 174
 175     @Test
 176     public void getNameScopeAndVersionFromPdpPolicyTest() {
 177         String fileName = "com.Decision_testname.1.xml";
 178         String[] expectedArray = new String[3];
 179         expectedArray[0] = "Decision_testname.1.xml";
 180         expectedArray[2] = "1";
 181         expectedArray[1] = "com";
 182
 183         String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
 184         Assert.assertArrayEquals(expectedArray, returnArray);
 185     }
 186
 187     @Test
 188     public void getPdpPolicyNameTest() {
 189         String name = "Decision_testname.1.json";
 190         String scope = "com";
 191         String expectedFinalname = "com.Decision_testname.1.xml";
 192
 193         String finalname = d.getPdpPolicyName(name, scope);
 194         Assert.assertEquals(expectedFinalname, finalname);
 195     }
 196
 197     @Test
 198     public void getPolicySubFileTest() {
 199         String name = "Config_testname.1.json";
 200         String subFileType = "Config";
 201         HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
 202
 203         Path path = handle.getPolicySubFile(name, subFileType);
 204         Assert.assertNull(path);
 205     }
 206
 207     @Test
 208     public void createFromPolicyObject() {
 209         Policy policyObject = new ConfigPolicy();
 210         policyObject.policyAdapter = new PolicyRestAdapter();
 211         policyObject.policyAdapter.setConfigName("testpolicy1");
 212         policyObject.policyAdapter.setPolicyDescription("my description");
 213         policyObject.policyAdapter.setConfigBodyData("this is my test config file");
 214         policyObject.policyAdapter.setPolicyName("SampleTest1206");
 215         policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
 216         policyObject.policyAdapter.setPolicyType("Config");
 217         policyObject.policyAdapter.setDomainDir("com");
 218         policyObject.policyAdapter.setVersion("1");
 219         policyObject.policyAdapter.setHighestVersion(1);
 220         PolicyType policyTypeObject = new PolicyType();
 221         policyObject.policyAdapter.setPolicyData(policyTypeObject);
 222         ClassLoader classLoader = getClass().getClassLoader();
 223         PolicyType policyConfig = new PolicyType();
 224         policyConfig.setVersion("1");
 225         policyConfig.setPolicyId("");
 226         policyConfig.setTarget(new TargetType());
 227         policyObject.policyAdapter.setData(policyConfig);
 228         try {
 229             policyObject.policyAdapter
 230                     .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
 231         } catch (Exception e2) {
 232             fail();
 233         }
 234
 235         PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
 236         try {
 237             transaction.createPolicy(policyObject, "testuser1");
 238             transaction.commitTransaction();
 239         } catch (Exception e) {
 240             transaction.rollbackTransaction();
 241             Assert.fail();
 242         }
 243
 244         Session session = sessionFactory.openSession();
 245         session.getTransaction().begin();
 246         Query policyQuery =
 247                 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
 248
 249         policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
 250         policyQuery.setParameter("scope", "com");
 251
 252         List<?> policyQueryList = policyQuery.list();
 253         PolicyEntity result = null;
 254         try {
 255             result = (PolicyEntity) policyQueryList.get(0);
 256         } catch (Exception e) {
 257             logger.error("Exception Occured " + e);
 258             Assert.fail();
 259         }
 260         session.getTransaction().commit();
 261         session.close();
 262
 263         String expectedData;
 264         try {
 265             expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
 266         } catch (IOException e1) {
 267             expectedData = "";
 268         }
 269         Assert.assertEquals(expectedData, result.getPolicyData());
 270         result = null;
 271
 272         Assert.assertFalse(transaction.isTransactionOpen());
 273     }
 274
 275     @Test
 276     public void groupTransactions() {
 277         PolicyDBDaoTransaction group = dbd.getNewTransaction();
 278         String groupName = "test group 1";
 279         try {
 280             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
 281                     "testuser");
 282             group.commitTransaction();
 283         } catch (Exception e) {
 284             group.rollbackTransaction();
 285             logger.error("Exception Occured" + e);
 286             Assert.fail();
 287         }
 288         Session session = sessionFactory.openSession();
 289         session.getTransaction().begin();
 290         Query getGroup =
 291                 session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 292         getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 293         getGroup.setParameter("deleted", false);
 294         List<?> groups = getGroup.list();
 295         GroupEntity groupEntity = (GroupEntity) groups.get(0);
 296         Assert.assertEquals(groupName, groupEntity.getgroupName());
 297         Assert.assertEquals("this is a test group", groupEntity.getDescription());
 298         session.getTransaction().commit();
 299         session.close();
 300
 301         group = dbd.getNewTransaction();
 302         try {
 303             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
 304             group.deleteGroup(groupToDelete, null, "testuser");
 305             group.commitTransaction();
 306         } catch (Exception e) {
 307             group.rollbackTransaction();
 308             logger.error("Exception Occured" + e);
 309             Assert.fail();
 310         }
 311         Session session2 = sessionFactory.openSession();
 312         session2.getTransaction().begin();
 313         Query getGroup2 =
 314                 session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 315         getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 316         getGroup2.setParameter("deleted", false);
 317         List<?> groups2 = getGroup2.list();
 318         groups2 = getGroup2.list();
 319         if (groups2.size() != 0) {
 320             System.out.println("Group size: " + groups2.size());
 321             Assert.fail();
 322         }
 323         session2.getTransaction().commit();
 324         session2.close();
 325
 326
 327         // add a pdp to a group
 328         group = dbd.getNewTransaction();
 329         try {
 330             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
 331             group.commitTransaction();
 332         } catch (Exception e) {
 333             group.rollbackTransaction();
 334             logger.error("Exception Occured" + e);
 335             Assert.fail();
 336         }
 337
 338         group = dbd.getNewTransaction();
 339         try {
 340             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary",
 341                     "the main pdp", 3232, "testuser");
 342             group.commitTransaction();
 343         } catch (Exception e) {
 344             group.rollbackTransaction();
 345             logger.error("Exception Occured" + e);
 346             Assert.fail();
 347         }
 348
 349         Session session3 = sessionFactory.openSession();
 350         session3.getTransaction().begin();
 351         Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 352         getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 353         getPdp.setParameter("deleted", false);
 354         List<?> pdps = getPdp.list();
 355         if (pdps.size() != 1) {
 356             System.out.println("Group size: " + pdps.size());
 357             Assert.fail();
 358         }
 359         PdpEntity pdp = (PdpEntity) pdps.get(0);
 360         Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
 361         Assert.assertEquals(pdp.getPdpName(), "primary");
 362         session3.getTransaction().commit();
 363         session3.close();
 364
 365
 366         group = dbd.getNewTransaction();
 367         try {
 368             group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
 369             group.commitTransaction();
 370         } catch (Exception e) {
 371             group.rollbackTransaction();
 372             logger.error("Exception Occured" + e);
 373             Assert.fail();
 374         }
 375
 376         Session session4 = sessionFactory.openSession();
 377         session4.getTransaction().begin();
 378         Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 379         getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
 380         getPdp2.setParameter("deleted", false);
 381         List<?> pdps2 = getPdp2.list();
 382         if (pdps2.size() != 0) {
 383             System.out.println("Group size: " + pdps2.size());
 384             Assert.fail();
 385         }
 386
 387         session4.getTransaction().commit();
 388         session4.close();
 389
 390         // add some pdps to groups
 391         group = dbd.getNewTransaction();
 392         try {
 393             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
 394             group.commitTransaction();
 395         } catch (Exception e) {
 396             group.rollbackTransaction();
 397             logger.error("Exception Occured" + e);
 398             Assert.fail();
 399         }
 400         group = dbd.getNewTransaction();
 401         try {
 402             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
 403             group.commitTransaction();
 404         } catch (Exception e) {
 405             group.rollbackTransaction();
 406             logger.error("Exception Occured" + e);
 407             Assert.fail();
 408         }
 409
 410         group = dbd.getNewTransaction();
 411         try {
 412             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
 413                     "the main pdp", 3232, "testuser");
 414             group.commitTransaction();
 415         } catch (Exception e) {
 416             group.rollbackTransaction();
 417             logger.error("Exception Occured" + e);
 418             Assert.fail();
 419         }
 420         group = dbd.getNewTransaction();
 421         try {
 422             group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
 423                     "secondary", "the second pdp", 3233, "testuser");
 424             group.commitTransaction();
 425         } catch (Exception e) {
 426             group.rollbackTransaction();
 427             logger.error("Exception Occured" + e);
 428             Assert.fail();
 429         }
 430
 431         Session session5 = sessionFactory.openSession();
 432         session5.getTransaction().begin();
 433         Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 434         getPdp3.setParameter("deleted", false);
 435         List<?> pdps3 = getPdp3.list();
 436         for (Object obj : pdps3) {
 437             Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
 438         }
 439
 440         session5.getTransaction().commit();
 441         session5.close();
 442
 443
 444         group = dbd.getNewTransaction();
 445         try {
 446             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), Paths.get("/"));
 447             OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
 448             group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
 449             group.commitTransaction();
 450         } catch (Exception e) {
 451             group.rollbackTransaction();
 452             logger.error("Exception Occured" + e);
 453             Assert.fail();
 454         }
 455
 456         Session session6 = sessionFactory.openSession();
 457         session6.getTransaction().begin();
 458         Query getGroup3 =
 459                 session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 460         getGroup3.setParameter("groupId", "testgroup1");
 461         getGroup3.setParameter("deleted", false);
 462         List<?> groups3 = getGroup3.list();
 463         if (groups3.size() != 0) {
 464             System.out.println("Group size: " + groups3.size());
 465             Assert.fail();
 466         }
 467
 468         session6.getTransaction().commit();
 469         session6.close();
 470
 471         Session session7 = sessionFactory.openSession();
 472         session7.getTransaction().begin();
 473         Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 474         getPdp4.setParameter("deleted", false);
 475         List<?> pdps4 = getPdp4.list();
 476         for (Object obj : pdps4) {
 477             Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getgroupName());
 478         }
 479
 480         session7.getTransaction().commit();
 481         session7.close();
 482
 483
 484         group = dbd.getNewTransaction();
 485         try {
 486             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
 487             OnapPDPGroup groupToMoveTo = null;
 488             group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
 489             group.commitTransaction();
 490             Assert.fail();
 491         } catch (PolicyDBException pe) {
 492             // good, can't delete group with pdps
 493             group.rollbackTransaction();
 494         } catch (Exception e) {
 495             group.rollbackTransaction();
 496             logger.error("Exception Occured" + e);
 497             Assert.fail();
 498         }
 499
 500         // update group
 501         OnapPDPGroup pdpGroup =
 502                 new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
 503         group = dbd.getNewTransaction();
 504         try {
 505             group.updateGroup(pdpGroup, "testuser", "testuser");
 506             group.commitTransaction();
 507         } catch (Exception e) {
 508             logger.error("Exception Occured" + e);
 509             group.rollbackTransaction();
 510             Assert.fail();
 511         }
 512
 513         Session session8 = sessionFactory.openSession();
 514         session8.getTransaction().begin();
 515         Query getGroup4 =
 516                 session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 517         getGroup4.setParameter("groupId", "newtestgroup2");
 518         getGroup4.setParameter("deleted", false);
 519         List<?> groups4 = getGroup4.list();
 520         if (groups4.size() != 1) {
 521             System.out.println("Group size: " + groups4.size());
 522             Assert.fail();
 523         }
 524
 525         session8.getTransaction().commit();
 526         session8.close();
 527
 528         Session session9 = sessionFactory.openSession();
 529         session9.getTransaction().begin();
 530         Query getGroup5 =
 531                 session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 532         getGroup5.setParameter("groupId", "testgroup2");
 533         getGroup5.setParameter("deleted", false);
 534         List<?> groups5 = getGroup5.list();
 535         if (groups5.size() != 0) {
 536             System.out.println("Group size: " + groups5.size());
 537             Assert.fail();
 538         }
 539
 540         session9.getTransaction().commit();
 541         session9.close();
 542     }
 543
 544     @Ignore
 545     @Test
 546     public void threadingStabilityTest() {
 547         if (logger.isDebugEnabled()) {
 548             logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
 549                     + "******************************\n\n");
 550         }
 551
 552         PolicyDBDaoTransaction t = dbd.getNewTransaction();
 553         Assert.assertTrue(t.isTransactionOpen());
 554         try {
 555             // Add 1000 ms to the timeout just to be sure it actually times out
 556             int sleepTime =
 557                     Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 558             if (logger.isDebugEnabled()) {
 559                 Date date = new java.util.Date();
 560                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   sleepTime =  " + sleepTime
 561                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 562             }
 563             Thread.sleep(sleepTime);
 564         } catch (InterruptedException e) {
 565             logger.error("Exception Occured" + e);
 566         }
 567         if (logger.isDebugEnabled()) {
 568             Date date = new java.util.Date();
 569             logger.debug(
 570                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertFalse(t.isTransactionOpen() = "
 571                             + t.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 572         }
 573         Assert.assertFalse(t.isTransactionOpen());
 574
 575
 576         if (logger.isDebugEnabled()) {
 577             Date date = new java.util.Date();
 578             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   a = dbd.getNewTransaction() "
 579                     + "\n   TimeStamp = " + date.getTime() + "\n\n");
 580         }
 581         PolicyDBDaoTransaction a = dbd.getNewTransaction();
 582         if (logger.isDebugEnabled()) {
 583             Date date = new java.util.Date();
 584             logger.debug(
 585                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(a.isTransactionOpen() = "
 586                             + a.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 587         }
 588         Assert.assertTrue(a.isTransactionOpen());
 589
 590         try {
 591             // Add 1000 ms to the timeout just to be sure it actually times out
 592             int sleepTime =
 593                     Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 594             if (logger.isDebugEnabled()) {
 595                 Date date = new java.util.Date();
 596                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   sleepTime =  " + sleepTime
 597                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 598             }
 599             Thread.sleep(sleepTime);
 600         } catch (InterruptedException e) {
 601             logger.error("Exception Occured" + e);
 602         }
 603         if (logger.isDebugEnabled()) {
 604             Date date = new java.util.Date();
 605             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   b = dbd.getNewTransaction() "
 606                     + "\n   TimeStamp = " + date.getTime() + "\n\n");
 607         }
 608         PolicyDBDaoTransaction b = dbd.getNewTransaction();
 609         if (logger.isDebugEnabled()) {
 610             Date date = new java.util.Date();
 611             logger.debug(
 612                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertFalse(a.isTransactionOpen() = "
 613                             + a.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 614         }
 615         Assert.assertFalse(a.isTransactionOpen());
 616         if (logger.isDebugEnabled()) {
 617             Date date = new java.util.Date();
 618             logger.debug(
 619                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(b.isTransactionOpen() = "
 620                             + b.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 621         }
 622         Assert.assertTrue(b.isTransactionOpen());
 623         b.close();
 624
 625
 626
 627         // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
 628         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT, "1000");
 629         // And let's lengthen the transaction timeout to 5000 ms
 630         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
 631         // get a transacton
 632         PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
 633         if (logger.isDebugEnabled()) {
 634             Date date = new java.util.Date();
 635             logger.debug(
 636                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(t1.isTransactionOpen() = "
 637                             + t1.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 638         }
 639         Assert.assertTrue(t1.isTransactionOpen());
 640         // while it is open, get another from a different DB Dao so it will not collide on the synchronized
 641         // code segment
 642         // but will collide at the DB. Remember that the wait time is only 1000 ms
 643         try {
 644             // Now the 2nd transaction has a wait timeout in 1000 ms
 645             PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
 646             /*
 647              * Give it plenty of time to time out the second transaction It will actually hang right here until
 648              * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
 649              * sloppy so, I have given this plenty of leeway.
 650              */
 651
 652             if (logger.isDebugEnabled()) {
 653                 Date date = new java.util.Date();
 654                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Thread.sleep(3000)"
 655                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 656             }
 657             Thread.sleep(3000);
 658             if (logger.isDebugEnabled()) {
 659                 Date date = new java.util.Date();
 660                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 661                         + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 662                         + "\n   Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
 663                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 664             }
 665             // Assert.assertTrue(t1.isTransactionOpen());
 666             // Assert.assertFalse(t2.isTransactionOpen());
 667
 668             Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
 669         } catch (PersistenceException e) {
 670             // success
 671             if (logger.isDebugEnabled()) {
 672                 Date date = new java.util.Date();
 673                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 674                         + "\n   SUCCESS! Transaction Wait Timeout worked!" + "\n   Caught PersistenceException = " + e
 675                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 676             }
 677         } catch (Exception e) {
 678             // failure due to some other reason
 679             if (logger.isDebugEnabled()) {
 680                 Date date = new java.util.Date();
 681                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n   Caught Exception = " + e
 682                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 683             }
 684             logger.error("Exception Occured" + e);
 685             Assert.fail();
 686         }
 687
 688         if (logger.isDebugEnabled()) {
 689             Date date = new java.util.Date();
 690             logger.debug("\n\nthreadingStabilityTest() exit" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 691         }
 692     }
 693
 694 }