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 import com.att.research.xacml.api.pap.PAPException;
  25 import com.att.research.xacml.util.XACMLProperties;
  26 import java.io.File;
  27 import java.io.IOException;
  28 import java.nio.file.Path;
  29 import java.nio.file.Paths;
  30 import java.util.Date;
  31 import java.util.List;
  32 import java.util.Properties;
  33 import javax.persistence.PersistenceException;
  34 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
  35 import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
  36 import org.apache.commons.io.FileUtils;
  37 import org.apache.commons.io.IOUtils;
  38 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
  39 import org.hibernate.Query;
  40 import org.hibernate.Session;
  41 import org.hibernate.SessionFactory;
  42 import org.junit.After;
  43 import org.junit.Assert;
  44 import org.junit.BeforeClass;
  45 import org.junit.Ignore;
  46 import org.junit.Test;
  47 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  48 import org.onap.policy.common.logging.flexlogger.Logger;
  49 import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
  50 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
  51 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
  52 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
  53 import org.onap.policy.rest.XACMLRestProperties;
  54 import org.onap.policy.rest.adapter.PolicyRestAdapter;
  55 import org.onap.policy.rest.dao.PolicyDBException;
  56 import org.onap.policy.rest.jpa.DatabaseLockEntity;
  57 import org.onap.policy.rest.jpa.GroupEntity;
  58 import org.onap.policy.rest.jpa.PdpEntity;
  59 import org.onap.policy.rest.jpa.PolicyEntity;
  60 import org.onap.policy.rest.jpa.UserInfo;
  61 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
  62 import org.onap.policy.xacml.std.pap.StdEngine;
  63 import org.onap.policy.xacml.std.pap.StdPDPGroup;
  64 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
  65
  66 public class PolicyDBDaoTest {
  67     private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
  68
  69     static PolicyDBDaoTestClass d;
  70     static PolicyDBDao dbd;
  71     static PolicyDBDao dbd2;
  72     private static Path repository;
  73     static StdEngine stdEngine = null;
  74     static SessionFactory sessionFactory = null;
  75
  76     @BeforeClass
  77     public static void init() throws PAPException, IOException {
  78         System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
  79         try {
  80             sessionFactory = setupH2DbDaoImpl("testdbdao");
  81             dbd = PolicyDBDao.getPolicyDBDaoInstance();
  82             dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
  83         } catch (Exception e) {
  84             Assert.fail();
  85         }
  86
  87         d = PolicyDBDao.getPolicyDBDaoTestClass();
  88         PolicyDBDao.setJunit(true);
  89         repository = Paths.get("src/test/resources/pdps");
  90         stdEngine = new StdEngine(repository);
  91         dbd.setPapEngine(stdEngine);
  92     }
  93
  94     @After
  95     public void cleanUp() {
  96         try {
  97             FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
  98         } catch (IOException e) {
  99             // could not delete
 100         }
 101     }
 102
 103     public static SessionFactory setupH2DbDaoImpl(String dbName) {
 104         System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
 105         BasicDataSource dataSource = new BasicDataSource();
 106         dataSource.setDriverClassName("org.h2.Driver");
 107         dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
 108         dataSource.setUsername("sa");
 109         dataSource.setPassword("");
 110         LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
 111         sessionBuilder.scanPackages("org.onap.*");
 112
 113         Properties properties = new Properties();
 114         properties.put("hibernate.show_sql", "false");
 115         properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
 116         properties.put("hibernate.hbm2ddl.auto", "create-drop");
 117
 118         sessionBuilder.addProperties(properties);
 119         SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
 120
 121         new PolicyDBDao(sessionFac);
 122         PolicyDbDaoTransactionInstance.setJunit(true);
 123         new PolicyDbDaoTransactionInstance(sessionFac);
 124         CommonClassDaoImpl.setSessionfactory(sessionFac);
 125         new DataToNotifyPdp(new CommonClassDaoImpl());
 126         PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
 127
 128         DatabaseLockEntity lock = null;
 129         Session session = sessionFac.openSession();
 130         session.getTransaction().begin();
 131         lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
 132         if (lock == null) {
 133             lock = new DatabaseLockEntity();
 134             lock.setKey(1);
 135             session.persist(lock);
 136             session.flush();
 137         }
 138         session.getTransaction().commit();
 139         session.close();
 140
 141         UserInfo user = new UserInfo();
 142         user.setUserLoginId("API");
 143         user.setUserName("API");
 144         Session session2 = sessionFac.openSession();
 145         session2.getTransaction().begin();
 146         session2.persist(user);
 147
 148         session2.getTransaction().commit();
 149         session2.close();
 150
 151         return sessionFac;
 152     }
 153
 154
 155     @Test
 156     public void testGetConfigFile() {
 157         PolicyRestAdapter pra = new PolicyRestAdapter();
 158         pra.setConfigType(ConfigPolicy.JSON_CONFIG);
 159         String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
 160         Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
 161         // yes, we can do action files too even though they don't have configs
 162         configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
 163         Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
 164     }
 165
 166     @Test
 167     public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
 168         String policyName = "com.Decision_testname.1.xml";
 169         String[] expectedNameAndVersion = new String[2];
 170         expectedNameAndVersion[0] = "com.Decision_testname";
 171         expectedNameAndVersion[1] = "1";
 172         String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
 173         Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
 174     }
 175
 176     @Test
 177     public void getNameScopeAndVersionFromPdpPolicyTest() {
 178         String fileName = "com.Decision_testname.1.xml";
 179         String[] expectedArray = new String[3];
 180         expectedArray[0] = "Decision_testname.1.xml";
 181         expectedArray[2] = "1";
 182         expectedArray[1] = "com";
 183
 184         String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
 185         Assert.assertArrayEquals(expectedArray, returnArray);
 186     }
 187
 188     @Test
 189     public void getPdpPolicyNameTest() {
 190         String name = "Decision_testname.1.json";
 191         String scope = "com";
 192         String expectedFinalname = "com.Decision_testname.1.xml";
 193
 194         String finalname = d.getPdpPolicyName(name, scope);
 195         Assert.assertEquals(expectedFinalname, finalname);
 196     }
 197
 198     @Test
 199     public void getPolicySubFileTest() {
 200         String name = "Config_testname.1.json";
 201         String subFileType = "Config";
 202         HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
 203
 204         Path path = handle.getPolicySubFile(name, subFileType);
 205         Assert.assertNull(path);
 206     }
 207
 208     @Test
 209     public void createFromPolicyObject() {
 210         Policy policyObject = new ConfigPolicy();
 211         policyObject.policyAdapter = new PolicyRestAdapter();
 212         policyObject.policyAdapter.setConfigName("testpolicy1");
 213         policyObject.policyAdapter.setPolicyDescription("my description");
 214         policyObject.policyAdapter.setConfigBodyData("this is my test config file");
 215         policyObject.policyAdapter.setPolicyName("SampleTest1206");
 216         policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
 217         policyObject.policyAdapter.setPolicyType("Config");
 218         policyObject.policyAdapter.setDomainDir("com");
 219         policyObject.policyAdapter.setVersion("1");
 220         policyObject.policyAdapter.setHighestVersion(1);
 221         PolicyType policyTypeObject = new PolicyType();
 222         policyObject.policyAdapter.setPolicyData(policyTypeObject);
 223         ClassLoader classLoader = getClass().getClassLoader();
 224         PolicyType policyConfig = new PolicyType();
 225         policyConfig.setVersion("1");
 226         policyConfig.setPolicyId("");
 227         policyConfig.setTarget(new TargetType());
 228         policyObject.policyAdapter.setData(policyConfig);
 229         try {
 230             policyObject.policyAdapter
 231                     .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
 232         } catch (Exception e2) {
 233             fail();
 234         }
 235
 236         PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
 237         try {
 238             transaction.createPolicy(policyObject, "testuser1");
 239             transaction.commitTransaction();
 240         } catch (Exception e) {
 241             transaction.rollbackTransaction();
 242             Assert.fail();
 243         }
 244
 245         Session session = sessionFactory.openSession();
 246         session.getTransaction().begin();
 247         Query policyQuery =
 248                 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
 249
 250         policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
 251         policyQuery.setParameter("scope", "com");
 252
 253         List<?> policyQueryList = policyQuery.list();
 254         PolicyEntity result = null;
 255         try {
 256             result = (PolicyEntity) policyQueryList.get(0);
 257         } catch (Exception e) {
 258             logger.error("Exception Occured " + e);
 259             Assert.fail();
 260         }
 261         session.getTransaction().commit();
 262         session.close();
 263
 264         String expectedData;
 265         try {
 266             expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
 267         } catch (IOException e1) {
 268             expectedData = "";
 269         }
 270         Assert.assertEquals(expectedData, result.getPolicyData());
 271         result = null;
 272
 273         Assert.assertFalse(transaction.isTransactionOpen());
 274     }
 275
 276     @Test
 277     public void groupTransactions() {
 278         PolicyDBDaoTransaction group = dbd.getNewTransaction();
 279         String groupName = "test group 1";
 280         try {
 281             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
 282                     "testuser");
 283             group.commitTransaction();
 284         } catch (Exception e) {
 285             group.rollbackTransaction();
 286             logger.error("Exception Occured" + e);
 287             Assert.fail();
 288         }
 289         Session session = sessionFactory.openSession();
 290         session.getTransaction().begin();
 291         Query getGroup =
 292                 session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 293         getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 294         getGroup.setParameter("deleted", false);
 295         List<?> groups = getGroup.list();
 296         GroupEntity groupEntity = (GroupEntity) groups.get(0);
 297         Assert.assertEquals(groupName, groupEntity.getgroupName());
 298         Assert.assertEquals("this is a test group", groupEntity.getDescription());
 299         session.getTransaction().commit();
 300         session.close();
 301
 302         group = dbd.getNewTransaction();
 303         try {
 304             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
 305             group.deleteGroup(groupToDelete, null, "testuser");
 306             group.commitTransaction();
 307         } catch (Exception e) {
 308             group.rollbackTransaction();
 309             logger.error("Exception Occured" + e);
 310             Assert.fail();
 311         }
 312         Session session2 = sessionFactory.openSession();
 313         session2.getTransaction().begin();
 314         Query getGroup2 =
 315                 session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 316         getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 317         getGroup2.setParameter("deleted", false);
 318         List<?> groups2 = getGroup2.list();
 319         groups2 = getGroup2.list();
 320         if (groups2.size() != 0) {
 321             System.out.println("Group size: " + groups2.size());
 322             Assert.fail();
 323         }
 324         session2.getTransaction().commit();
 325         session2.close();
 326
 327
 328         // add a pdp to a group
 329         group = dbd.getNewTransaction();
 330         try {
 331             group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
 332             group.commitTransaction();
 333         } catch (Exception e) {
 334             group.rollbackTransaction();
 335             logger.error("Exception Occured" + e);
 336             Assert.fail();
 337         }
 338
 339         group = dbd.getNewTransaction();
 340         try {
 341             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary",
 342                     "the main pdp", 3232, "testuser");
 343             group.commitTransaction();
 344         } catch (Exception e) {
 345             group.rollbackTransaction();
 346             logger.error("Exception Occured" + e);
 347             Assert.fail();
 348         }
 349
 350         Session session3 = sessionFactory.openSession();
 351         session3.getTransaction().begin();
 352         Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 353         getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 354         getPdp.setParameter("deleted", false);
 355         List<?> pdps = getPdp.list();
 356         if (pdps.size() != 1) {
 357             System.out.println("Group size: " + pdps.size());
 358             Assert.fail();
 359         }
 360         PdpEntity pdp = (PdpEntity) pdps.get(0);
 361         Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
 362         Assert.assertEquals(pdp.getPdpName(), "primary");
 363         session3.getTransaction().commit();
 364         session3.close();
 365
 366
 367         group = dbd.getNewTransaction();
 368         try {
 369             group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
 370             group.commitTransaction();
 371         } catch (Exception e) {
 372             group.rollbackTransaction();
 373             logger.error("Exception Occured" + e);
 374             Assert.fail();
 375         }
 376
 377         Session session4 = sessionFactory.openSession();
 378         session4.getTransaction().begin();
 379         Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 380         getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
 381         getPdp2.setParameter("deleted", false);
 382         List<?> pdps2 = getPdp2.list();
 383         if (pdps2.size() != 0) {
 384             System.out.println("Group size: " + pdps2.size());
 385             Assert.fail();
 386         }
 387
 388         session4.getTransaction().commit();
 389         session4.close();
 390
 391         // add some pdps to groups
 392         group = dbd.getNewTransaction();
 393         try {
 394             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
 395             group.commitTransaction();
 396         } catch (Exception e) {
 397             group.rollbackTransaction();
 398             logger.error("Exception Occured" + e);
 399             Assert.fail();
 400         }
 401         group = dbd.getNewTransaction();
 402         try {
 403             group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
 404             group.commitTransaction();
 405         } catch (Exception e) {
 406             group.rollbackTransaction();
 407             logger.error("Exception Occured" + e);
 408             Assert.fail();
 409         }
 410
 411         group = dbd.getNewTransaction();
 412         try {
 413             group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
 414                     "the main pdp", 3232, "testuser");
 415             group.commitTransaction();
 416         } catch (Exception e) {
 417             group.rollbackTransaction();
 418             logger.error("Exception Occured" + e);
 419             Assert.fail();
 420         }
 421         group = dbd.getNewTransaction();
 422         try {
 423             group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
 424                     "secondary", "the second pdp", 3233, "testuser");
 425             group.commitTransaction();
 426         } catch (Exception e) {
 427             group.rollbackTransaction();
 428             logger.error("Exception Occured" + e);
 429             Assert.fail();
 430         }
 431
 432         Session session5 = sessionFactory.openSession();
 433         session5.getTransaction().begin();
 434         Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 435         getPdp3.setParameter("deleted", false);
 436         List<?> pdps3 = getPdp3.list();
 437         for (Object obj : pdps3) {
 438             Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
 439         }
 440
 441         session5.getTransaction().commit();
 442         session5.close();
 443
 444
 445         group = dbd.getNewTransaction();
 446         try {
 447             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), Paths.get("/"));
 448             OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
 449             group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
 450             group.commitTransaction();
 451         } catch (Exception e) {
 452             group.rollbackTransaction();
 453             logger.error("Exception Occured" + e);
 454             Assert.fail();
 455         }
 456
 457         Session session6 = sessionFactory.openSession();
 458         session6.getTransaction().begin();
 459         Query getGroup3 =
 460                 session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 461         getGroup3.setParameter("groupId", "testgroup1");
 462         getGroup3.setParameter("deleted", false);
 463         List<?> groups3 = getGroup3.list();
 464         if (groups3.size() != 0) {
 465             System.out.println("Group size: " + groups3.size());
 466             Assert.fail();
 467         }
 468
 469         session6.getTransaction().commit();
 470         session6.close();
 471
 472         Session session7 = sessionFactory.openSession();
 473         session7.getTransaction().begin();
 474         Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 475         getPdp4.setParameter("deleted", false);
 476         List<?> pdps4 = getPdp4.list();
 477         for (Object obj : pdps4) {
 478             Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getgroupName());
 479         }
 480
 481         session7.getTransaction().commit();
 482         session7.close();
 483
 484
 485         group = dbd.getNewTransaction();
 486         try {
 487             OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
 488             OnapPDPGroup groupToMoveTo = null;
 489             group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
 490             group.commitTransaction();
 491             Assert.fail();
 492         } catch (PolicyDBException pe) {
 493             // good, can't delete group with pdps
 494             group.rollbackTransaction();
 495         } catch (Exception e) {
 496             group.rollbackTransaction();
 497             logger.error("Exception Occured" + e);
 498             Assert.fail();
 499         }
 500
 501         // update group
 502         OnapPDPGroup pdpGroup =
 503                 new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
 504         group = dbd.getNewTransaction();
 505         try {
 506             group.updateGroup(pdpGroup, "testuser", "testuser");
 507             group.commitTransaction();
 508         } catch (Exception e) {
 509             logger.error("Exception Occured" + e);
 510             group.rollbackTransaction();
 511             Assert.fail();
 512         }
 513
 514         Session session8 = sessionFactory.openSession();
 515         session8.getTransaction().begin();
 516         Query getGroup4 =
 517                 session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 518         getGroup4.setParameter("groupId", "newtestgroup2");
 519         getGroup4.setParameter("deleted", false);
 520         List<?> groups4 = getGroup4.list();
 521         if (groups4.size() != 1) {
 522             System.out.println("Group size: " + groups4.size());
 523             Assert.fail();
 524         }
 525
 526         session8.getTransaction().commit();
 527         session8.close();
 528
 529         Session session9 = sessionFactory.openSession();
 530         session9.getTransaction().begin();
 531         Query getGroup5 =
 532                 session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 533         getGroup5.setParameter("groupId", "testgroup2");
 534         getGroup5.setParameter("deleted", false);
 535         List<?> groups5 = getGroup5.list();
 536         if (groups5.size() != 0) {
 537             System.out.println("Group size: " + groups5.size());
 538             Assert.fail();
 539         }
 540
 541         session9.getTransaction().commit();
 542         session9.close();
 543     }
 544
 545     @Ignore
 546     @Test
 547     public void threadingStabilityTest() {
 548         if (logger.isDebugEnabled()) {
 549             logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
 550                     + "******************************\n\n");
 551         }
 552
 553         PolicyDBDaoTransaction t = dbd.getNewTransaction();
 554         Assert.assertTrue(t.isTransactionOpen());
 555         try {
 556             // Add 1000 ms to the timeout just to be sure it actually times out
 557             int sleepTime =
 558                     Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 559             if (logger.isDebugEnabled()) {
 560                 Date date = new java.util.Date();
 561                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   sleepTime =  " + sleepTime
 562                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 563             }
 564             Thread.sleep(sleepTime);
 565         } catch (InterruptedException e) {
 566             logger.error("Exception Occured" + e);
 567         }
 568         if (logger.isDebugEnabled()) {
 569             Date date = new java.util.Date();
 570             logger.debug(
 571                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertFalse(t.isTransactionOpen() = "
 572                             + t.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 573         }
 574         Assert.assertFalse(t.isTransactionOpen());
 575
 576
 577         if (logger.isDebugEnabled()) {
 578             Date date = new java.util.Date();
 579             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   a = dbd.getNewTransaction() "
 580                     + "\n   TimeStamp = " + date.getTime() + "\n\n");
 581         }
 582         PolicyDBDaoTransaction a = dbd.getNewTransaction();
 583         if (logger.isDebugEnabled()) {
 584             Date date = new java.util.Date();
 585             logger.debug(
 586                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(a.isTransactionOpen() = "
 587                             + a.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 588         }
 589         Assert.assertTrue(a.isTransactionOpen());
 590
 591         try {
 592             // Add 1000 ms to the timeout just to be sure it actually times out
 593             int sleepTime =
 594                     Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 595             if (logger.isDebugEnabled()) {
 596                 Date date = new java.util.Date();
 597                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   sleepTime =  " + sleepTime
 598                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 599             }
 600             Thread.sleep(sleepTime);
 601         } catch (InterruptedException e) {
 602             logger.error("Exception Occured" + e);
 603         }
 604         if (logger.isDebugEnabled()) {
 605             Date date = new java.util.Date();
 606             logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   b = dbd.getNewTransaction() "
 607                     + "\n   TimeStamp = " + date.getTime() + "\n\n");
 608         }
 609         PolicyDBDaoTransaction b = dbd.getNewTransaction();
 610         if (logger.isDebugEnabled()) {
 611             Date date = new java.util.Date();
 612             logger.debug(
 613                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertFalse(a.isTransactionOpen() = "
 614                             + a.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 615         }
 616         Assert.assertFalse(a.isTransactionOpen());
 617         if (logger.isDebugEnabled()) {
 618             Date date = new java.util.Date();
 619             logger.debug(
 620                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(b.isTransactionOpen() = "
 621                             + b.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 622         }
 623         Assert.assertTrue(b.isTransactionOpen());
 624         b.close();
 625
 626
 627
 628         // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
 629         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT, "1000");
 630         // And let's lengthen the transaction timeout to 5000 ms
 631         System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
 632         // get a transacton
 633         PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
 634         if (logger.isDebugEnabled()) {
 635             Date date = new java.util.Date();
 636             logger.debug(
 637                     "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Assert.assertTrue(t1.isTransactionOpen() = "
 638                             + t1.isTransactionOpen() + ")" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 639         }
 640         Assert.assertTrue(t1.isTransactionOpen());
 641         // while it is open, get another from a different DB Dao so it will not collide on the synchronized
 642         // code segment
 643         // but will collide at the DB. Remember that the wait time is only 1000 ms
 644         try {
 645             // Now the 2nd transaction has a wait timeout in 1000 ms
 646             PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
 647             /*
 648              * Give it plenty of time to time out the second transaction It will actually hang right here until
 649              * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
 650              * sloppy so, I have given this plenty of leeway.
 651              */
 652
 653             if (logger.isDebugEnabled()) {
 654                 Date date = new java.util.Date();
 655                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n   Thread.sleep(3000)"
 656                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 657             }
 658             Thread.sleep(3000);
 659             if (logger.isDebugEnabled()) {
 660                 Date date = new java.util.Date();
 661                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 662                         + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 663                         + "\n   Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
 664                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 665             }
 666             // Assert.assertTrue(t1.isTransactionOpen());
 667             // Assert.assertFalse(t2.isTransactionOpen());
 668
 669             Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
 670         } catch (PersistenceException e) {
 671             // success
 672             if (logger.isDebugEnabled()) {
 673                 Date date = new java.util.Date();
 674                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 675                         + "\n   SUCCESS! Transaction Wait Timeout worked!" + "\n   Caught PersistenceException = " + e
 676                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 677             }
 678         } catch (Exception e) {
 679             // failure due to some other reason
 680             if (logger.isDebugEnabled()) {
 681                 Date date = new java.util.Date();
 682                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n   Caught Exception = " + e
 683                         + "\n   TimeStamp = " + date.getTime() + "\n\n");
 684             }
 685             logger.error("Exception Occured" + e);
 686             Assert.fail();
 687         }
 688
 689         if (logger.isDebugEnabled()) {
 690             Date date = new java.util.Date();
 691             logger.debug("\n\nthreadingStabilityTest() exit" + "\n   TimeStamp = " + date.getTime() + "\n\n");
 692         }
 693     }
 694
 695 }