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