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