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-2018 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
  25 import java.io.File;
  26 import java.io.IOException;
  27 import java.nio.file.Path;
  28 import java.nio.file.Paths;
  29 import java.util.Date;
  30 import java.util.List;
  31
  32 import javax.persistence.EntityManager;
  33 import javax.persistence.EntityManagerFactory;
  34 import javax.persistence.Persistence;
  35 import javax.persistence.PersistenceException;
  36 import javax.persistence.Query;
  37
  38 import org.apache.commons.io.FileUtils;
  39 import org.apache.commons.io.IOUtils;
  40 import org.junit.After;
  41 import org.junit.Assert;
  42 import org.junit.Before;
  43 import org.junit.Ignore;
  44 import org.junit.Test;
  45 import org.mockito.Mockito;
  46 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  47 import org.onap.policy.common.logging.flexlogger.Logger;
  48 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
  49 import org.onap.policy.rest.XACMLRestProperties;
  50 import org.onap.policy.rest.adapter.PolicyRestAdapter;
  51 import org.onap.policy.rest.dao.PolicyDBException;
  52 import org.onap.policy.rest.jpa.GroupEntity;
  53 import org.onap.policy.rest.jpa.PdpEntity;
  54 import org.onap.policy.rest.jpa.PolicyEntity;
  55 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
  56 import org.onap.policy.xacml.std.pap.StdEngine;
  57 import org.onap.policy.xacml.std.pap.StdPDPGroup;
  58 import org.onap.policy.xacml.util.XACMLPolicyWriter;
  59
  60 import com.att.research.xacml.api.pap.PAPException;
  61 import com.att.research.xacml.util.XACMLProperties;
  62
  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 extends Mockito{
  67
  68     private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
  69
  70     PolicyDBDaoTestClass d;
  71     PolicyDBDao dbd;
  72     PolicyDBDao dbd2;
  73     EntityManagerFactory emf;
  74     private Path repository;
  75     StdEngine stdEngine = null;
  76
  77     @Before
  78     public void init() throws PAPException, IOException{
  79         System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME,"src/test/resources/xacml.pap.properties");
  80         emf = Persistence.createEntityManagerFactory("testPapPU");
  81         EntityManager em = emf.createEntityManager();
  82         em.getTransaction().begin();
  83         try{
  84             em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
  85             em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
  86             em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
  87             em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
  88             em.createQuery("DELETE FROM PdpEntity").executeUpdate();
  89             em.createQuery("DELETE FROM GroupEntity").executeUpdate();
  90
  91             em.getTransaction().commit();
  92         } catch(Exception e){
  93             logger.error("Exception Occured"+e);
  94             em.getTransaction().rollback();
  95         }
  96         em.close();
  97         try {
  98             dbd = PolicyDBDao.getPolicyDBDaoInstance(emf);
  99             dbd2 = PolicyDBDao.getPolicyDBDaoInstance(emf);
 100         } catch (Exception e) {
 101             Assert.fail();
 102         }
 103
 104         d = PolicyDBDao.getPolicyDBDaoTestClass();
 105         PolicyDBDao.setJunit(true);
 106         repository = Paths.get("src/test/resources/pdps");
 107         stdEngine = new StdEngine(repository);
 108         dbd.setPapEngine(stdEngine);
 109     }
 110
 111     @After
 112     public void cleanUp(){
 113         PolicyDBDao.setJunit(false);
 114         EntityManager em = emf.createEntityManager();
 115         em.getTransaction().begin();
 116         try{
 117         em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
 118         em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
 119         em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
 120         em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
 121         em.createQuery("DELETE FROM PdpEntity").executeUpdate();
 122         em.createQuery("DELETE FROM GroupEntity").executeUpdate();
 123
 124         em.getTransaction().commit();
 125         } catch(Exception e){
 126             em.getTransaction().rollback();
 127         }
 128         em.close();
 129         try {
 130             FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
 131         } catch (IOException e) {
 132             //could not delete
 133         }
 134     }
 135
 136     @Test
 137     public void getConfigFileTest(){
 138         PolicyRestAdapter pra = new PolicyRestAdapter();
 139         pra.setConfigType(ConfigPolicy.JSON_CONFIG);
 140         String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
 141         Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
 142         //yes, we can do action files too even though they don't have configs
 143         configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
 144         Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
 145     }
 146
 147     @Test
 148     public void createFromPolicyObject(){
 149         Policy policyObject = new ConfigPolicy();
 150         policyObject.policyAdapter = new PolicyRestAdapter();
 151         policyObject.policyAdapter.setConfigName("testpolicy1");
 152         policyObject.policyAdapter.setPolicyDescription("my description");
 153         policyObject.policyAdapter.setConfigBodyData("this is my test config file");
 154         policyObject.policyAdapter.setPolicyName("SampleTest1206");
 155         policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
 156         policyObject.policyAdapter.setPolicyType("Config");
 157         policyObject.policyAdapter.setDomainDir("com");
 158         policyObject.policyAdapter.setVersion("1");
 159         PolicyType policyTypeObject = new PolicyType();
 160         policyObject.policyAdapter.setPolicyData(policyTypeObject);
 161         ClassLoader classLoader = getClass().getClassLoader();
 162         PolicyType policyConfig = new PolicyType();
 163         policyConfig.setVersion(Integer.toString(1));
 164         policyConfig.setPolicyId("");
 165         policyConfig.setTarget(new TargetType());
 166         policyObject.policyAdapter.setData(policyConfig);
 167         mock(XACMLPolicyWriter.class);
 168         try {
 169             policyObject.policyAdapter.setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
 170         } catch (Exception e2) {
 171             fail();
 172         }
 173
 174         PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
 175         try{
 176             transaction.createPolicy(policyObject, "testuser1");
 177             transaction.commitTransaction();
 178         } catch(Exception e){
 179             transaction.rollbackTransaction();
 180             Assert.fail();
 181         }
 182
 183         EntityManager getData = emf.createEntityManager();
 184         Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
 185         getDataQuery.setParameter("scope", "com");
 186         getDataQuery.setParameter("name","Config_SampleTest1206.1.xml");
 187         PolicyEntity result = null;
 188         try{
 189             result = (PolicyEntity)getDataQuery.getSingleResult();
 190         } catch(Exception e){
 191             logger.error("Exception Occured"+e);
 192             Assert.fail();
 193         }
 194         String expectedData;
 195         try {
 196             expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
 197         } catch (IOException e1) {
 198             expectedData = "";
 199         }
 200         Assert.assertEquals(expectedData, result.getPolicyData());
 201         getData.close();
 202         result = null;
 203
 204         transaction.commitTransaction();
 205         Assert.assertFalse(transaction.isTransactionOpen());
 206     }
 207
 208     @Test
 209     public void groupTransactions(){
 210         PolicyDBDaoTransaction group = dbd.getNewTransaction();
 211         String groupName = "test group 1";
 212         try{
 213             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group","testuser");
 214             group.commitTransaction();
 215         } catch(Exception e){
 216             group.rollbackTransaction();
 217             logger.error("Exception Occured"+e);
 218             Assert.fail();
 219         }
 220         EntityManager em = emf.createEntityManager();
 221         Query getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 222         getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 223         getGroup.setParameter("deleted", false);
 224         List<?> groups = getGroup.getResultList();
 225         if(groups.size() != 1){
 226             Assert.fail();
 227         }
 228         GroupEntity groupEntity = (GroupEntity)groups.get(0);
 229         em.close();
 230         Assert.assertEquals(groupName, groupEntity.getgroupName());
 231         Assert.assertEquals("this is a test group", groupEntity.getDescription());
 232         group = dbd.getNewTransaction();
 233         try{
 234             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName),Paths.get("/"));
 235             group.deleteGroup(groupToDelete, null,"testuser");
 236             group.commitTransaction();
 237         } catch(Exception e){
 238             group.rollbackTransaction();
 239             logger.error("Exception Occured"+e);
 240             Assert.fail();
 241         }
 242         em = emf.createEntityManager();
 243         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 244         getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 245         getGroup.setParameter("deleted", false);
 246         groups = getGroup.getResultList();
 247         if(groups.size() != 0){
 248             System.out.println("Group size: "+groups.size());
 249             Assert.fail();
 250         }
 251         em.close();
 252         //add a pdp to a group
 253         group = dbd.getNewTransaction();
 254         try{
 255             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
 256             group.commitTransaction();
 257         } catch(Exception e){
 258             group.rollbackTransaction();
 259             logger.error("Exception Occured"+e);
 260             Assert.fail();
 261         }
 262         group = dbd.getNewTransaction();
 263         try{
 264             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary", "the main pdp", 3232, "testuser");
 265             group.commitTransaction();
 266         } catch(Exception e){
 267             group.rollbackTransaction();
 268             logger.error("Exception Occured"+e);
 269             Assert.fail();
 270         }
 271         em = emf.createEntityManager();
 272         Query getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 273         getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 274         getPdp.setParameter("deleted", false);
 275         List<?> pdps = getPdp.getResultList();
 276         if(pdps.size() != 1){
 277             System.out.println("Group size: "+pdps.size());
 278             Assert.fail();
 279         }
 280         PdpEntity pdp = (PdpEntity)pdps.get(0);
 281         Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
 282         Assert.assertEquals(pdp.getPdpName(), "primary");
 283         em.close();
 284         group = dbd.getNewTransaction();
 285         try{
 286             group.removePdpFromGroup("http://localhost:4344/pdp/","testuser");
 287             group.commitTransaction();
 288         } catch(Exception e){
 289             group.rollbackTransaction();
 290             logger.error("Exception Occured"+e);
 291             Assert.fail();
 292         }
 293         em = emf.createEntityManager();
 294         getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 295         getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 296         getPdp.setParameter("deleted", false);
 297         pdps = getPdp.getResultList();
 298         if(pdps.size() != 0){
 299             System.out.println("Group size: "+pdps.size());
 300             Assert.fail();
 301         }
 302         em.close();
 303
 304         //add some pdps to groups
 305         group = dbd.getNewTransaction();
 306         try{
 307             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
 308             group.commitTransaction();
 309         } catch(Exception e){
 310             group.rollbackTransaction();
 311             logger.error("Exception Occured"+e);
 312             Assert.fail();
 313         }
 314         group = dbd.getNewTransaction();
 315         try{
 316             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
 317             group.commitTransaction();
 318         } catch(Exception e){
 319             group.rollbackTransaction();
 320             logger.error("Exception Occured"+e);
 321             Assert.fail();
 322         }
 323
 324         group = dbd.getNewTransaction();
 325         try{
 326             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary", "the main pdp", 3232, "testuser");
 327             group.commitTransaction();
 328         } catch(Exception e){
 329             group.rollbackTransaction();
 330             logger.error("Exception Occured"+e);
 331             Assert.fail();
 332         }
 333         group = dbd.getNewTransaction();
 334         try{
 335             group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "secondary", "the second pdp", 3233, "testuser");
 336             group.commitTransaction();
 337         } catch(Exception e){
 338             group.rollbackTransaction();
 339             logger.error("Exception Occured"+e);
 340             Assert.fail();
 341         }
 342         em = emf.createEntityManager();
 343         getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 344         getPdp.setParameter("deleted", false);
 345         pdps = getPdp.getResultList();
 346         for(Object o : pdps){
 347             Assert.assertEquals("testgroup1",((PdpEntity)o).getGroup().getgroupName());
 348         }
 349         em.close();
 350
 351         group = dbd.getNewTransaction();
 352         try{
 353             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"),Paths.get("/"));
 354             OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
 355             group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
 356             group.commitTransaction();
 357         } catch(Exception e){
 358             group.rollbackTransaction();
 359             logger.error("Exception Occured"+e);
 360             Assert.fail();
 361         }
 362         em = emf.createEntityManager();
 363         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 364         getGroup.setParameter("groupId", "testgroup1");
 365         getGroup.setParameter("deleted", false);
 366         groups = getGroup.getResultList();
 367         if(groups.size() != 0){
 368             System.out.println("Group size: "+groups.size());
 369             Assert.fail();
 370         }
 371         em.close();
 372
 373         em = emf.createEntityManager();
 374         getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 375         getPdp.setParameter("deleted", false);
 376         pdps = getPdp.getResultList();
 377         for(Object o : pdps){
 378             Assert.assertEquals("testgroup2",((PdpEntity)o).getGroup().getgroupName());
 379         }
 380         em.close();
 381
 382         group = dbd.getNewTransaction();
 383         try{
 384             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
 385             OnapPDPGroup groupToMoveTo = null;
 386             group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
 387             group.commitTransaction();
 388             Assert.fail();
 389         } catch(PolicyDBException pe){
 390             //good, can't delete group with pdps
 391             group.rollbackTransaction();
 392         } catch(Exception e){
 393             group.rollbackTransaction();
 394             logger.error("Exception Occured"+e);
 395             Assert.fail();
 396         }
 397
 398         //update group
 399         OnapPDPGroup pdpGroup = new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
 400         group = dbd.getNewTransaction();
 401         try{
 402             group.updateGroup(pdpGroup, "testuser");
 403             group.commitTransaction();
 404         }catch (Exception e){
 405             logger.error("Exception Occured"+e);
 406             group.rollbackTransaction();
 407             Assert.fail();
 408         }
 409         em = emf.createEntityManager();
 410         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 411         getGroup.setParameter("groupId", "newtestgroup2");
 412         getGroup.setParameter("deleted", false);
 413         groups = getGroup.getResultList();
 414         if(groups.size() != 1){
 415             System.out.println("Group size: "+groups.size());
 416             Assert.fail();
 417         }
 418         em.close();
 419         em = emf.createEntityManager();
 420         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 421         getGroup.setParameter("groupId", "testgroup2");
 422         getGroup.setParameter("deleted", false);
 423         groups = getGroup.getResultList();
 424         if(groups.size() != 0){
 425             System.out.println("Group size: "+groups.size());
 426             Assert.fail();
 427         }
 428         em.close();
 429     }
 430
 431     @Ignore
 432     @Test
 433     public void threadingStabilityTest(){
 434         if(logger.isDebugEnabled()){
 435             logger.debug("\n\n****************************"
 436                     + "threadingStabilityTest() entry"
 437                     + "******************************\n\n");
 438         }
 439
 440         PolicyDBDaoTransaction t = dbd.getNewTransaction();
 441         Assert.assertTrue(t.isTransactionOpen());
 442         try {
 443             //Add 1000 ms to the timeout just to be sure it actually times out
 444             int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 445             if(logger.isDebugEnabled()){
 446                 Date date= new java.util.Date();
 447                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 448                         + "\n   sleepTime =  " + sleepTime
 449                         + "\n   TimeStamp = " + date.getTime()
 450                         + "\n\n");
 451             }
 452             Thread.sleep(sleepTime);
 453         } catch (InterruptedException e) {
 454             logger.error("Exception Occured"+e);
 455         }
 456         if(logger.isDebugEnabled()){
 457             Date date= new java.util.Date();
 458             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 459                     + "\n   Assert.assertFalse(t.isTransactionOpen() = " + t.isTransactionOpen() + ")"
 460                     + "\n   TimeStamp = " + date.getTime()
 461                     + "\n\n");
 462         }
 463         Assert.assertFalse(t.isTransactionOpen());
 464
 465
 466         if(logger.isDebugEnabled()){
 467             Date date= new java.util.Date();
 468             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 469                     + "\n   a = dbd.getNewTransaction() "
 470                     + "\n   TimeStamp = " + date.getTime()
 471                     + "\n\n");
 472         }
 473         PolicyDBDaoTransaction a = dbd.getNewTransaction();
 474         if(logger.isDebugEnabled()){
 475             Date date= new java.util.Date();
 476             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 477                     + "\n   Assert.assertTrue(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
 478                     + "\n   TimeStamp = " + date.getTime()
 479                     + "\n\n");
 480         }
 481         Assert.assertTrue(a.isTransactionOpen());
 482
 483         try {
 484             //Add 1000 ms to the timeout just to be sure it actually times out
 485             int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 486             if(logger.isDebugEnabled()){
 487                 Date date= new java.util.Date();
 488                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 489                         + "\n   sleepTime =  " + sleepTime
 490                         + "\n   TimeStamp = " + date.getTime()
 491                         + "\n\n");
 492             }
 493             Thread.sleep(sleepTime);
 494         } catch (InterruptedException e) {
 495             logger.error("Exception Occured"+e);
 496         }
 497         if(logger.isDebugEnabled()){
 498             Date date= new java.util.Date();
 499             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 500                     + "\n   b = dbd.getNewTransaction() "
 501                     + "\n   TimeStamp = " + date.getTime()
 502                     + "\n\n");
 503         }
 504         PolicyDBDaoTransaction b = dbd.getNewTransaction();
 505         if(logger.isDebugEnabled()){
 506             Date date= new java.util.Date();
 507             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 508                     + "\n   Assert.assertFalse(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
 509                     + "\n   TimeStamp = " + date.getTime()
 510                     + "\n\n");
 511         }
 512         Assert.assertFalse(a.isTransactionOpen());
 513         if(logger.isDebugEnabled()){
 514             Date date= new java.util.Date();
 515             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 516                     + "\n   Assert.assertTrue(b.isTransactionOpen() = " + b.isTransactionOpen() + ")"
 517                     + "\n   TimeStamp = " + date.getTime()
 518                     + "\n\n");
 519         }
 520         Assert.assertTrue(b.isTransactionOpen());
 521         b.close();
 522
 523
 524
 525         //Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
 526         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT,"1000");
 527         //And let's lengthen the transaction timeout to 5000 ms
 528         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT,"5000");
 529         //get a transacton
 530         PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
 531         if(logger.isDebugEnabled()){
 532             Date date= new java.util.Date();
 533             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 534                     + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 535                     + "\n   TimeStamp = " + date.getTime()
 536                     + "\n\n");
 537         }
 538         Assert.assertTrue(t1.isTransactionOpen());
 539         //while it is open, get another from a different DB Dao so it will not collide on the synchronized code segment
 540         //but will collide at the DB. Remember that the wait time is only 1000 ms
 541         try {
 542             //Now the 2nd transaction has a wait timeout in 1000 ms
 543             PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
 544             /*
 545              * Give it plenty of time to time out the second transaction
 546              * It will actually hang right here until it either gets the lock from the DB or the
 547              * request for the DB lock times out. The timers are very sloppy so, I have given
 548              * this plenty of leeway.
 549              */
 550
 551             if(logger.isDebugEnabled()){
 552                 Date date= new java.util.Date();
 553                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 554                         + "\n   Thread.sleep(3000)"
 555                         + "\n   TimeStamp = " + date.getTime()
 556                         + "\n\n");
 557             }
 558             Thread.sleep(3000);
 559             if(logger.isDebugEnabled()){
 560                 Date date= new java.util.Date();
 561                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 562                         + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 563                         + "\n   Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
 564                         + "\n   TimeStamp = " + date.getTime()
 565                         + "\n\n");
 566             }
 567             //Assert.assertTrue(t1.isTransactionOpen());
 568             //Assert.assertFalse(t2.isTransactionOpen());
 569
 570             Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
 571         } catch (PersistenceException e) {
 572             //success
 573             if(logger.isDebugEnabled()){
 574                 Date date= new java.util.Date();
 575                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 576                         + "\n   SUCCESS! Transaction Wait Timeout worked!"
 577                         + "\n   Caught PersistenceException = " + e
 578                         + "\n   TimeStamp = " + date.getTime()
 579                         + "\n\n");
 580             }
 581         } catch (Exception e) {
 582             // failure due to some other reason
 583             if(logger.isDebugEnabled()){
 584                 Date date= new java.util.Date();
 585                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE"
 586                         + "\n   Caught Exception = " + e
 587                         + "\n   TimeStamp = " + date.getTime()
 588                         + "\n\n");
 589             }
 590             logger.error("Exception Occured"+e);
 591             Assert.fail();
 592         }
 593
 594         if(logger.isDebugEnabled()){
 595             Date date= new java.util.Date();
 596             logger.debug("\n\nthreadingStabilityTest() exit"
 597                     + "\n   TimeStamp = " + date.getTime()
 598                     + "\n\n");
 599         }
 600     }
 601
 602 }