ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTest.java

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