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