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 }