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