2 * ============LICENSE_START=======================================================
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
22 package org.onap.policy.pap.xacml.rest.components;
24 import static org.junit.Assert.fail;
26 import com.att.research.xacml.api.pap.PAPException;
27 import com.att.research.xacml.util.XACMLProperties;
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;
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;
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;
72 public class PolicyDBDaoTest {
73 private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
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;
83 public static void init() throws PAPException, IOException {
84 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
86 sessionFactory = setupH2DbDaoImpl("testdbdao");
87 dbd = PolicyDbDao.getPolicyDbDaoInstance();
88 dbd2 = PolicyDbDao.getPolicyDbDaoInstance();
89 } catch (Exception e) {
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);
101 public void cleanUp() {
103 FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
104 } catch (IOException e) {
109 public static SessionFactory setupH2DbDaoImpl(String dbName) {
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.*");
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");
126 sessionBuilder.addProperties(properties);
127 SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
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());
136 DatabaseLockEntity lock = null;
137 Session session = sessionFac.openSession();
138 session.getTransaction().begin();
139 lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
141 lock = new DatabaseLockEntity();
143 session.persist(lock);
146 session.getTransaction().commit();
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);
156 session2.getTransaction().commit();
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, "");
169 // create the DB and then close it
170 Persistence.createEntityManagerFactory("testPapPU", properties).close();
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);
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);
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";
202 String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
203 Assert.assertArrayEquals(expectedArray, returnArray);
207 public void getPdpPolicyNameTest() {
208 String name = "Decision_testname.1.json";
209 String scope = "com";
210 String expectedFinalname = "com.Decision_testname.1.xml";
212 String finalname = d.getPdpPolicyName(name, scope);
213 Assert.assertEquals(expectedFinalname, finalname);
217 public void getPolicySubFileTest() {
218 String name = "Config_testname.1.json";
219 String subFileType = "Config";
220 HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
222 Path path = handle.getPolicySubFile(name, subFileType);
223 Assert.assertNull(path);
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);
248 policyObject.policyAdapter
249 .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
250 } catch (Exception e2) {
254 PolicyDbDaoTransaction transaction = dbd.getNewTransaction();
256 transaction.createPolicy(policyObject, "testuser1");
257 transaction.commitTransaction();
258 } catch (Exception e) {
259 transaction.rollbackTransaction();
263 Session session = sessionFactory.openSession();
264 session.getTransaction().begin();
266 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
268 policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
269 policyQuery.setParameter("scope", "com");
271 List<?> policyQueryList = policyQuery.list();
272 PolicyEntity result = null;
274 result = (PolicyEntity) policyQueryList.get(0);
275 } catch (Exception e) {
276 logger.error("Exception Occured " + e);
279 session.getTransaction().commit();
284 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
285 } catch (IOException e1) {
288 Assert.assertEquals(expectedData, result.getPolicyData());
291 Assert.assertFalse(transaction.isTransactionOpen());
295 public void groupTransactions() {
296 PolicyDbDaoTransaction group = dbd.getNewTransaction();
297 String groupName = "test group 1";
299 group.createGroup(PolicyDbDao.createNewPdpGroupId(groupName), groupName, "this is a test group",
301 group.commitTransaction();
302 } catch (Exception e) {
303 group.rollbackTransaction();
304 logger.error("Exception Occured" + e);
307 Session session = sessionFactory.openSession();
308 session.getTransaction().begin();
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();
320 group = dbd.getNewTransaction();
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);
330 Session session2 = sessionFactory.openSession();
331 session2.getTransaction().begin();
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());
342 session2.getTransaction().commit();
345 // add a pdp to a group
346 group = dbd.getNewTransaction();
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);
356 group = dbd.getNewTransaction();
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);
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());
377 PdpEntity pdp = (PdpEntity) pdps.get(0);
378 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
379 Assert.assertEquals(pdp.getPdpName(), "primary");
380 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();
460 group = dbd.getNewTransaction();
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);
472 Session session6 = sessionFactory.openSession();
473 session6.getTransaction().begin();
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());
484 session6.getTransaction().commit();
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());
496 session7.getTransaction().commit();
499 group = dbd.getNewTransaction();
501 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDbDao.createNewPdpGroupId("testgroup2"), Paths.get("/"));
502 OnapPDPGroup groupToMoveTo = null;
503 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
504 group.commitTransaction();
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);
516 OnapPDPGroup pdpGroup =
517 new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
518 group = dbd.getNewTransaction();
520 group.updateGroup(pdpGroup, "testuser", "testuser");
521 group.commitTransaction();
522 } catch (Exception e) {
523 logger.error("Exception Occured" + e);
524 group.rollbackTransaction();
528 Session session8 = sessionFactory.openSession();
529 session8.getTransaction().begin();
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());
540 session8.getTransaction().commit();
543 Session session9 = sessionFactory.openSession();
544 session9.getTransaction().begin();
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());
555 session9.getTransaction().commit();
561 public void threadingStabilityTest() {
562 if (logger.isDebugEnabled()) {
563 logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
564 + "******************************\n\n");
567 PolicyDbDaoTransaction t = dbd.getNewTransaction();
568 Assert.assertTrue(t.isTransactionOpen());
570 // Add 1000 ms to the timeout just to be sure it actually times out
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");
578 Thread.sleep(sleepTime);
579 } catch (InterruptedException e) {
580 logger.error("Exception Occured" + e);
582 if (logger.isDebugEnabled()) {
583 Date date = new java.util.Date();
585 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(t.isTransactionOpen() = "
586 + t.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
588 Assert.assertFalse(t.isTransactionOpen());
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");
595 PolicyDbDaoTransaction a = dbd.getNewTransaction();
596 if (logger.isDebugEnabled()) {
597 Date date = new java.util.Date();
599 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
600 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
602 Assert.assertTrue(a.isTransactionOpen());
605 // Add 1000 ms to the timeout just to be sure it actually times out
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");
613 Thread.sleep(sleepTime);
614 } catch (InterruptedException e) {
615 logger.error("Exception Occured" + e);
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");
622 PolicyDbDaoTransaction b = dbd.getNewTransaction();
623 if (logger.isDebugEnabled()) {
624 Date date = new java.util.Date();
626 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
627 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
629 Assert.assertFalse(a.isTransactionOpen());
630 if (logger.isDebugEnabled()) {
631 Date date = new java.util.Date();
633 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
634 + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
636 Assert.assertTrue(b.isTransactionOpen());
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");
644 PolicyDbDaoTransaction t1 = dbd.getNewTransaction();
645 if (logger.isDebugEnabled()) {
646 Date date = new java.util.Date();
648 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
649 + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
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
654 // but will collide at the DB. Remember that the wait time is only 1000 ms
656 // Now the 2nd transaction has a wait timeout in 1000 ms
657 PolicyDbDaoTransaction t2 = dbd2.getNewTransaction();
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.
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");
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");
677 // Assert.assertTrue(t1.isTransactionOpen());
678 // Assert.assertFalse(t2.isTransactionOpen());
680 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
681 } catch (PersistenceException e) {
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");
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");
696 logger.error("Exception Occured" + e);
700 if (logger.isDebugEnabled()) {
701 Date date = new java.util.Date();
702 logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");