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         policyObject.policyAdapter.setHighestVersion(1);
 160         PolicyType policyTypeObject = new PolicyType();
 161         policyObject.policyAdapter.setPolicyData(policyTypeObject);
 162         ClassLoader classLoader = getClass().getClassLoader();
 163         PolicyType policyConfig = new PolicyType();
 164         policyConfig.setVersion(Integer.toString(1));
 165         policyConfig.setPolicyId("");
 166         policyConfig.setTarget(new TargetType());
 167         policyObject.policyAdapter.setData(policyConfig);
 168         mock(XACMLPolicyWriter.class);
 169         try {
 170             policyObject.policyAdapter.setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
 171         } catch (Exception e2) {
 172             fail();
 173         }
 174
 175         PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
 176         try{
 177             transaction.createPolicy(policyObject, "testuser1");
 178             transaction.commitTransaction();
 179         } catch(Exception e){
 180             transaction.rollbackTransaction();
 181             Assert.fail();
 182         }
 183
 184         EntityManager getData = emf.createEntityManager();
 185         Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
 186         getDataQuery.setParameter("scope", "com");
 187         getDataQuery.setParameter("name","Config_SampleTest1206.1.xml");
 188         PolicyEntity result = null;
 189         try{
 190             result = (PolicyEntity)getDataQuery.getSingleResult();
 191         } catch(Exception e){
 192             logger.error("Exception Occured"+e);
 193             Assert.fail();
 194         }
 195         String expectedData;
 196         try {
 197             expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
 198         } catch (IOException e1) {
 199             expectedData = "";
 200         }
 201         Assert.assertEquals(expectedData, result.getPolicyData());
 202         getData.close();
 203         result = null;
 204
 205         transaction.commitTransaction();
 206         Assert.assertFalse(transaction.isTransactionOpen());
 207     }
 208
 209     @Test
 210     public void groupTransactions(){
 211         PolicyDBDaoTransaction group = dbd.getNewTransaction();
 212         String groupName = "test group 1";
 213         try{
 214             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group","testuser");
 215             group.commitTransaction();
 216         } catch(Exception e){
 217             group.rollbackTransaction();
 218             logger.error("Exception Occured"+e);
 219             Assert.fail();
 220         }
 221         EntityManager em = emf.createEntityManager();
 222         Query getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 223         getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 224         getGroup.setParameter("deleted", false);
 225         List<?> groups = getGroup.getResultList();
 226         if(groups.size() != 1){
 227             Assert.fail();
 228         }
 229         GroupEntity groupEntity = (GroupEntity)groups.get(0);
 230         em.close();
 231         Assert.assertEquals(groupName, groupEntity.getgroupName());
 232         Assert.assertEquals("this is a test group", groupEntity.getDescription());
 233         group = dbd.getNewTransaction();
 234         try{
 235             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName),Paths.get("/"));
 236             group.deleteGroup(groupToDelete, null,"testuser");
 237             group.commitTransaction();
 238         } catch(Exception e){
 239             group.rollbackTransaction();
 240             logger.error("Exception Occured"+e);
 241             Assert.fail();
 242         }
 243         em = emf.createEntityManager();
 244         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 245         getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 246         getGroup.setParameter("deleted", false);
 247         groups = getGroup.getResultList();
 248         if(groups.size() != 0){
 249             System.out.println("Group size: "+groups.size());
 250             Assert.fail();
 251         }
 252         em.close();
 253         //add a pdp to a group
 254         group = dbd.getNewTransaction();
 255         try{
 256             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
 257             group.commitTransaction();
 258         } catch(Exception e){
 259             group.rollbackTransaction();
 260             logger.error("Exception Occured"+e);
 261             Assert.fail();
 262         }
 263         group = dbd.getNewTransaction();
 264         try{
 265             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary", "the main pdp", 3232, "testuser");
 266             group.commitTransaction();
 267         } catch(Exception e){
 268             group.rollbackTransaction();
 269             logger.error("Exception Occured"+e);
 270             Assert.fail();
 271         }
 272         em = emf.createEntityManager();
 273         Query getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 274         getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 275         getPdp.setParameter("deleted", false);
 276         List<?> pdps = getPdp.getResultList();
 277         if(pdps.size() != 1){
 278             System.out.println("Group size: "+pdps.size());
 279             Assert.fail();
 280         }
 281         PdpEntity pdp = (PdpEntity)pdps.get(0);
 282         Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
 283         Assert.assertEquals(pdp.getPdpName(), "primary");
 284         em.close();
 285         group = dbd.getNewTransaction();
 286         try{
 287             group.removePdpFromGroup("http://localhost:4344/pdp/","testuser");
 288             group.commitTransaction();
 289         } catch(Exception e){
 290             group.rollbackTransaction();
 291             logger.error("Exception Occured"+e);
 292             Assert.fail();
 293         }
 294         em = emf.createEntityManager();
 295         getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 296         getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 297         getPdp.setParameter("deleted", false);
 298         pdps = getPdp.getResultList();
 299         if(pdps.size() != 0){
 300             System.out.println("Group size: "+pdps.size());
 301             Assert.fail();
 302         }
 303         em.close();
 304
 305         //add some pdps to groups
 306         group = dbd.getNewTransaction();
 307         try{
 308             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
 309             group.commitTransaction();
 310         } catch(Exception e){
 311             group.rollbackTransaction();
 312             logger.error("Exception Occured"+e);
 313             Assert.fail();
 314         }
 315         group = dbd.getNewTransaction();
 316         try{
 317             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
 318             group.commitTransaction();
 319         } catch(Exception e){
 320             group.rollbackTransaction();
 321             logger.error("Exception Occured"+e);
 322             Assert.fail();
 323         }
 324
 325         group = dbd.getNewTransaction();
 326         try{
 327             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary", "the main pdp", 3232, "testuser");
 328             group.commitTransaction();
 329         } catch(Exception e){
 330             group.rollbackTransaction();
 331             logger.error("Exception Occured"+e);
 332             Assert.fail();
 333         }
 334         group = dbd.getNewTransaction();
 335         try{
 336             group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "secondary", "the second pdp", 3233, "testuser");
 337             group.commitTransaction();
 338         } catch(Exception e){
 339             group.rollbackTransaction();
 340             logger.error("Exception Occured"+e);
 341             Assert.fail();
 342         }
 343         em = emf.createEntityManager();
 344         getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 345         getPdp.setParameter("deleted", false);
 346         pdps = getPdp.getResultList();
 347         for(Object o : pdps){
 348             Assert.assertEquals("testgroup1",((PdpEntity)o).getGroup().getgroupName());
 349         }
 350         em.close();
 351
 352         group = dbd.getNewTransaction();
 353         try{
 354             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"),Paths.get("/"));
 355             OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
 356             group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
 357             group.commitTransaction();
 358         } catch(Exception e){
 359             group.rollbackTransaction();
 360             logger.error("Exception Occured"+e);
 361             Assert.fail();
 362         }
 363         em = emf.createEntityManager();
 364         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 365         getGroup.setParameter("groupId", "testgroup1");
 366         getGroup.setParameter("deleted", false);
 367         groups = getGroup.getResultList();
 368         if(groups.size() != 0){
 369             System.out.println("Group size: "+groups.size());
 370             Assert.fail();
 371         }
 372         em.close();
 373
 374         em = emf.createEntityManager();
 375         getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 376         getPdp.setParameter("deleted", false);
 377         pdps = getPdp.getResultList();
 378         for(Object o : pdps){
 379             Assert.assertEquals("testgroup2",((PdpEntity)o).getGroup().getgroupName());
 380         }
 381         em.close();
 382
 383         group = dbd.getNewTransaction();
 384         try{
 385             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
 386             OnapPDPGroup groupToMoveTo = null;
 387             group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
 388             group.commitTransaction();
 389             Assert.fail();
 390         } catch(PolicyDBException pe){
 391             //good, can't delete group with pdps
 392             group.rollbackTransaction();
 393         } catch(Exception e){
 394             group.rollbackTransaction();
 395             logger.error("Exception Occured"+e);
 396             Assert.fail();
 397         }
 398
 399         //update group
 400         OnapPDPGroup pdpGroup = new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
 401         group = dbd.getNewTransaction();
 402         try{
 403             group.updateGroup(pdpGroup, "testuser");
 404             group.commitTransaction();
 405         }catch (Exception e){
 406             logger.error("Exception Occured"+e);
 407             group.rollbackTransaction();
 408             Assert.fail();
 409         }
 410         em = emf.createEntityManager();
 411         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 412         getGroup.setParameter("groupId", "newtestgroup2");
 413         getGroup.setParameter("deleted", false);
 414         groups = getGroup.getResultList();
 415         if(groups.size() != 1){
 416             System.out.println("Group size: "+groups.size());
 417             Assert.fail();
 418         }
 419         em.close();
 420         em = emf.createEntityManager();
 421         getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 422         getGroup.setParameter("groupId", "testgroup2");
 423         getGroup.setParameter("deleted", false);
 424         groups = getGroup.getResultList();
 425         if(groups.size() != 0){
 426             System.out.println("Group size: "+groups.size());
 427             Assert.fail();
 428         }
 429         em.close();
 430     }
 431
 432     @Ignore
 433     @Test
 434     public void threadingStabilityTest(){
 435         if(logger.isDebugEnabled()){
 436             logger.debug("\n\n****************************"
 437                     + "threadingStabilityTest() entry"
 438                     + "******************************\n\n");
 439         }
 440
 441         PolicyDBDaoTransaction t = dbd.getNewTransaction();
 442         Assert.assertTrue(t.isTransactionOpen());
 443         try {
 444             //Add 1000 ms to the timeout just to be sure it actually times out
 445             int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 446             if(logger.isDebugEnabled()){
 447                 Date date= new java.util.Date();
 448                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 449                         + "\n   sleepTime =  " + sleepTime
 450                         + "\n   TimeStamp = " + date.getTime()
 451                         + "\n\n");
 452             }
 453             Thread.sleep(sleepTime);
 454         } catch (InterruptedException e) {
 455             logger.error("Exception Occured"+e);
 456         }
 457         if(logger.isDebugEnabled()){
 458             Date date= new java.util.Date();
 459             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 460                     + "\n   Assert.assertFalse(t.isTransactionOpen() = " + t.isTransactionOpen() + ")"
 461                     + "\n   TimeStamp = " + date.getTime()
 462                     + "\n\n");
 463         }
 464         Assert.assertFalse(t.isTransactionOpen());
 465
 466
 467         if(logger.isDebugEnabled()){
 468             Date date= new java.util.Date();
 469             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 470                     + "\n   a = dbd.getNewTransaction() "
 471                     + "\n   TimeStamp = " + date.getTime()
 472                     + "\n\n");
 473         }
 474         PolicyDBDaoTransaction a = dbd.getNewTransaction();
 475         if(logger.isDebugEnabled()){
 476             Date date= new java.util.Date();
 477             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 478                     + "\n   Assert.assertTrue(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
 479                     + "\n   TimeStamp = " + date.getTime()
 480                     + "\n\n");
 481         }
 482         Assert.assertTrue(a.isTransactionOpen());
 483
 484         try {
 485             //Add 1000 ms to the timeout just to be sure it actually times out
 486             int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 487             if(logger.isDebugEnabled()){
 488                 Date date= new java.util.Date();
 489                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 490                         + "\n   sleepTime =  " + sleepTime
 491                         + "\n   TimeStamp = " + date.getTime()
 492                         + "\n\n");
 493             }
 494             Thread.sleep(sleepTime);
 495         } catch (InterruptedException e) {
 496             logger.error("Exception Occured"+e);
 497         }
 498         if(logger.isDebugEnabled()){
 499             Date date= new java.util.Date();
 500             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 501                     + "\n   b = dbd.getNewTransaction() "
 502                     + "\n   TimeStamp = " + date.getTime()
 503                     + "\n\n");
 504         }
 505         PolicyDBDaoTransaction b = dbd.getNewTransaction();
 506         if(logger.isDebugEnabled()){
 507             Date date= new java.util.Date();
 508             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 509                     + "\n   Assert.assertFalse(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
 510                     + "\n   TimeStamp = " + date.getTime()
 511                     + "\n\n");
 512         }
 513         Assert.assertFalse(a.isTransactionOpen());
 514         if(logger.isDebugEnabled()){
 515             Date date= new java.util.Date();
 516             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 517                     + "\n   Assert.assertTrue(b.isTransactionOpen() = " + b.isTransactionOpen() + ")"
 518                     + "\n   TimeStamp = " + date.getTime()
 519                     + "\n\n");
 520         }
 521         Assert.assertTrue(b.isTransactionOpen());
 522         b.close();
 523
 524
 525
 526         //Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
 527         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT,"1000");
 528         //And let's lengthen the transaction timeout to 5000 ms
 529         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT,"5000");
 530         //get a transacton
 531         PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
 532         if(logger.isDebugEnabled()){
 533             Date date= new java.util.Date();
 534             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 535                     + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 536                     + "\n   TimeStamp = " + date.getTime()
 537                     + "\n\n");
 538         }
 539         Assert.assertTrue(t1.isTransactionOpen());
 540         //while it is open, get another from a different DB Dao so it will not collide on the synchronized code segment
 541         //but will collide at the DB. Remember that the wait time is only 1000 ms
 542         try {
 543             //Now the 2nd transaction has a wait timeout in 1000 ms
 544             PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
 545             /*
 546              * Give it plenty of time to time out the second transaction
 547              * It will actually hang right here until it either gets the lock from the DB or the
 548              * request for the DB lock times out. The timers are very sloppy so, I have given
 549              * this plenty of leeway.
 550              */
 551
 552             if(logger.isDebugEnabled()){
 553                 Date date= new java.util.Date();
 554                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 555                         + "\n   Thread.sleep(3000)"
 556                         + "\n   TimeStamp = " + date.getTime()
 557                         + "\n\n");
 558             }
 559             Thread.sleep(3000);
 560             if(logger.isDebugEnabled()){
 561                 Date date= new java.util.Date();
 562                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 563                         + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 564                         + "\n   Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
 565                         + "\n   TimeStamp = " + date.getTime()
 566                         + "\n\n");
 567             }
 568             //Assert.assertTrue(t1.isTransactionOpen());
 569             //Assert.assertFalse(t2.isTransactionOpen());
 570
 571             Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
 572         } catch (PersistenceException e) {
 573             //success
 574             if(logger.isDebugEnabled()){
 575                 Date date= new java.util.Date();
 576                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 577                         + "\n   SUCCESS! Transaction Wait Timeout worked!"
 578                         + "\n   Caught PersistenceException = " + e
 579                         + "\n   TimeStamp = " + date.getTime()
 580                         + "\n\n");
 581             }
 582         } catch (Exception e) {
 583             // failure due to some other reason
 584             if(logger.isDebugEnabled()){
 585                 Date date= new java.util.Date();
 586                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE"
 587                         + "\n   Caught Exception = " + e
 588                         + "\n   TimeStamp = " + date.getTime()
 589                         + "\n\n");
 590             }
 591             logger.error("Exception Occured"+e);
 592             Assert.fail();
 593         }
 594
 595         if(logger.isDebugEnabled()){
 596             Date date= new java.util.Date();
 597             logger.debug("\n\nthreadingStabilityTest() exit"
 598                     + "\n   TimeStamp = " + date.getTime()
 599                     + "\n\n");
 600         }
 601     }
 602
 603 }