2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.onap.policy.pap.xacml.rest.components;
23 import static org.junit.Assert.fail;
24 import com.att.research.xacml.api.pap.PAPException;
25 import com.att.research.xacml.util.XACMLProperties;
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;
69 public class PolicyDBDaoTest {
70 private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
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;
80 public static void init() throws PAPException, IOException {
81 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
83 sessionFactory = setupH2DbDaoImpl("testdbdao");
84 dbd = PolicyDBDao.getPolicyDBDaoInstance();
85 dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
86 } catch (Exception e) {
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);
98 public void cleanUp() {
100 FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
101 } catch (IOException e) {
106 public static SessionFactory setupH2DbDaoImpl(String dbName) {
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.*");
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");
123 sessionBuilder.addProperties(properties);
124 SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
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());
133 DatabaseLockEntity lock = null;
134 Session session = sessionFac.openSession();
135 session.getTransaction().begin();
136 lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
138 lock = new DatabaseLockEntity();
140 session.persist(lock);
143 session.getTransaction().commit();
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);
153 session2.getTransaction().commit();
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, "");
167 // create the DB and then close it
168 Persistence.createEntityManagerFactory("testPapPU", properties).close();
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);
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);
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";
200 String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
201 Assert.assertArrayEquals(expectedArray, returnArray);
205 public void getPdpPolicyNameTest() {
206 String name = "Decision_testname.1.json";
207 String scope = "com";
208 String expectedFinalname = "com.Decision_testname.1.xml";
210 String finalname = d.getPdpPolicyName(name, scope);
211 Assert.assertEquals(expectedFinalname, finalname);
215 public void getPolicySubFileTest() {
216 String name = "Config_testname.1.json";
217 String subFileType = "Config";
218 HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
220 Path path = handle.getPolicySubFile(name, subFileType);
221 Assert.assertNull(path);
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);
246 policyObject.policyAdapter
247 .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
248 } catch (Exception e2) {
252 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
254 transaction.createPolicy(policyObject, "testuser1");
255 transaction.commitTransaction();
256 } catch (Exception e) {
257 transaction.rollbackTransaction();
261 Session session = sessionFactory.openSession();
262 session.getTransaction().begin();
264 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
266 policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
267 policyQuery.setParameter("scope", "com");
269 List<?> policyQueryList = policyQuery.list();
270 PolicyEntity result = null;
272 result = (PolicyEntity) policyQueryList.get(0);
273 } catch (Exception e) {
274 logger.error("Exception Occured " + e);
277 session.getTransaction().commit();
282 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
283 } catch (IOException e1) {
286 Assert.assertEquals(expectedData, result.getPolicyData());
289 Assert.assertFalse(transaction.isTransactionOpen());
293 public void groupTransactions() {
294 PolicyDBDaoTransaction group = dbd.getNewTransaction();
295 String groupName = "test group 1";
297 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
299 group.commitTransaction();
300 } catch (Exception e) {
301 group.rollbackTransaction();
302 logger.error("Exception Occured" + e);
305 Session session = sessionFactory.openSession();
306 session.getTransaction().begin();
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();
318 group = dbd.getNewTransaction();
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);
328 Session session2 = sessionFactory.openSession();
329 session2.getTransaction().begin();
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());
340 session2.getTransaction().commit();
344 // add a pdp to a group
345 group = dbd.getNewTransaction();
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);
355 group = dbd.getNewTransaction();
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);
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());
376 PdpEntity pdp = (PdpEntity) pdps.get(0);
377 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
378 Assert.assertEquals(pdp.getPdpName(), "primary");
379 session3.getTransaction().commit();
383 group = dbd.getNewTransaction();
385 group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
386 group.commitTransaction();
387 } catch (Exception e) {
388 group.rollbackTransaction();
389 logger.error("Exception Occured" + e);
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());
404 session4.getTransaction().commit();
407 // add some pdps to groups
408 group = dbd.getNewTransaction();
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);
417 group = dbd.getNewTransaction();
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);
427 group = dbd.getNewTransaction();
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);
437 group = dbd.getNewTransaction();
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);
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());
457 session5.getTransaction().commit();
461 group = dbd.getNewTransaction();
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);
473 Session session6 = sessionFactory.openSession();
474 session6.getTransaction().begin();
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());
485 session6.getTransaction().commit();
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());
497 session7.getTransaction().commit();
501 group = dbd.getNewTransaction();
503 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
504 OnapPDPGroup groupToMoveTo = null;
505 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
506 group.commitTransaction();
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);
518 OnapPDPGroup pdpGroup =
519 new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
520 group = dbd.getNewTransaction();
522 group.updateGroup(pdpGroup, "testuser", "testuser");
523 group.commitTransaction();
524 } catch (Exception e) {
525 logger.error("Exception Occured" + e);
526 group.rollbackTransaction();
530 Session session8 = sessionFactory.openSession();
531 session8.getTransaction().begin();
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());
542 session8.getTransaction().commit();
545 Session session9 = sessionFactory.openSession();
546 session9.getTransaction().begin();
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());
557 session9.getTransaction().commit();
563 public void threadingStabilityTest() {
564 if (logger.isDebugEnabled()) {
565 logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
566 + "******************************\n\n");
569 PolicyDBDaoTransaction t = dbd.getNewTransaction();
570 Assert.assertTrue(t.isTransactionOpen());
572 // Add 1000 ms to the timeout just to be sure it actually times out
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");
580 Thread.sleep(sleepTime);
581 } catch (InterruptedException e) {
582 logger.error("Exception Occured" + e);
584 if (logger.isDebugEnabled()) {
585 Date date = new java.util.Date();
587 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(t.isTransactionOpen() = "
588 + t.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
590 Assert.assertFalse(t.isTransactionOpen());
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");
598 PolicyDBDaoTransaction a = dbd.getNewTransaction();
599 if (logger.isDebugEnabled()) {
600 Date date = new java.util.Date();
602 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
603 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
605 Assert.assertTrue(a.isTransactionOpen());
608 // Add 1000 ms to the timeout just to be sure it actually times out
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");
616 Thread.sleep(sleepTime);
617 } catch (InterruptedException e) {
618 logger.error("Exception Occured" + e);
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");
625 PolicyDBDaoTransaction b = dbd.getNewTransaction();
626 if (logger.isDebugEnabled()) {
627 Date date = new java.util.Date();
629 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
630 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
632 Assert.assertFalse(a.isTransactionOpen());
633 if (logger.isDebugEnabled()) {
634 Date date = new java.util.Date();
636 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
637 + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
639 Assert.assertTrue(b.isTransactionOpen());
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");
649 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
650 if (logger.isDebugEnabled()) {
651 Date date = new java.util.Date();
653 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
654 + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
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
659 // but will collide at the DB. Remember that the wait time is only 1000 ms
661 // Now the 2nd transaction has a wait timeout in 1000 ms
662 PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
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.
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");
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");
682 // Assert.assertTrue(t1.isTransactionOpen());
683 // Assert.assertFalse(t2.isTransactionOpen());
685 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
686 } catch (PersistenceException e) {
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");
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");
701 logger.error("Exception Occured" + e);
705 if (logger.isDebugEnabled()) {
706 Date date = new java.util.Date();
707 logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");