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