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.PersistenceException;
34 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
35 import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
36 import org.apache.commons.io.FileUtils;
37 import org.apache.commons.io.IOUtils;
38 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
39 import org.hibernate.Query;
40 import org.hibernate.Session;
41 import org.hibernate.SessionFactory;
42 import org.junit.After;
43 import org.junit.Assert;
44 import org.junit.BeforeClass;
45 import org.junit.Ignore;
46 import org.junit.Test;
47 import org.onap.policy.common.logging.flexlogger.FlexLogger;
48 import org.onap.policy.common.logging.flexlogger.Logger;
49 import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
50 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
51 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
52 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
53 import org.onap.policy.rest.XACMLRestProperties;
54 import org.onap.policy.rest.adapter.PolicyRestAdapter;
55 import org.onap.policy.rest.dao.PolicyDBException;
56 import org.onap.policy.rest.jpa.DatabaseLockEntity;
57 import org.onap.policy.rest.jpa.GroupEntity;
58 import org.onap.policy.rest.jpa.PdpEntity;
59 import org.onap.policy.rest.jpa.PolicyEntity;
60 import org.onap.policy.rest.jpa.UserInfo;
61 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
62 import org.onap.policy.xacml.std.pap.StdEngine;
63 import org.onap.policy.xacml.std.pap.StdPDPGroup;
64 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
66 public class PolicyDBDaoTest {
67 private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
69 static PolicyDBDaoTestClass d;
70 static PolicyDBDao dbd;
71 static PolicyDBDao dbd2;
72 private static Path repository;
73 static StdEngine stdEngine = null;
74 static SessionFactory sessionFactory = null;
77 public static void init() throws PAPException, IOException {
78 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
80 sessionFactory = setupH2DbDaoImpl("testdbdao");
81 dbd = PolicyDBDao.getPolicyDBDaoInstance();
82 dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
83 } catch (Exception e) {
87 d = PolicyDBDao.getPolicyDBDaoTestClass();
88 PolicyDBDao.setJunit(true);
89 repository = Paths.get("src/test/resources/pdps");
90 stdEngine = new StdEngine(repository);
91 dbd.setPapEngine(stdEngine);
95 public void cleanUp() {
97 FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
98 } catch (IOException e) {
103 public static SessionFactory setupH2DbDaoImpl(String dbName) {
104 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
105 BasicDataSource dataSource = new BasicDataSource();
106 dataSource.setDriverClassName("org.h2.Driver");
107 dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
108 dataSource.setUsername("sa");
109 dataSource.setPassword("");
110 LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
111 sessionBuilder.scanPackages("org.onap.*");
113 Properties properties = new Properties();
114 properties.put("hibernate.show_sql", "false");
115 properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
116 properties.put("hibernate.hbm2ddl.auto", "create-drop");
118 sessionBuilder.addProperties(properties);
119 SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
121 new PolicyDBDao(sessionFac);
122 PolicyDbDaoTransactionInstance.setJunit(true);
123 new PolicyDbDaoTransactionInstance(sessionFac);
124 CommonClassDaoImpl.setSessionfactory(sessionFac);
125 new DataToNotifyPdp(new CommonClassDaoImpl());
126 PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
128 DatabaseLockEntity lock = null;
129 Session session = sessionFac.openSession();
130 session.getTransaction().begin();
131 lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
133 lock = new DatabaseLockEntity();
135 session.persist(lock);
138 session.getTransaction().commit();
141 UserInfo user = new UserInfo();
142 user.setUserLoginId("API");
143 user.setUserName("API");
144 Session session2 = sessionFac.openSession();
145 session2.getTransaction().begin();
146 session2.persist(user);
148 session2.getTransaction().commit();
156 public void testGetConfigFile() {
157 PolicyRestAdapter pra = new PolicyRestAdapter();
158 pra.setConfigType(ConfigPolicy.JSON_CONFIG);
159 String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
160 Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
161 // yes, we can do action files too even though they don't have configs
162 configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
163 Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
167 public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
168 String policyName = "com.Decision_testname.1.xml";
169 String[] expectedNameAndVersion = new String[2];
170 expectedNameAndVersion[0] = "com.Decision_testname";
171 expectedNameAndVersion[1] = "1";
172 String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
173 Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
177 public void getNameScopeAndVersionFromPdpPolicyTest() {
178 String fileName = "com.Decision_testname.1.xml";
179 String[] expectedArray = new String[3];
180 expectedArray[0] = "Decision_testname.1.xml";
181 expectedArray[2] = "1";
182 expectedArray[1] = "com";
184 String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
185 Assert.assertArrayEquals(expectedArray, returnArray);
189 public void getPdpPolicyNameTest() {
190 String name = "Decision_testname.1.json";
191 String scope = "com";
192 String expectedFinalname = "com.Decision_testname.1.xml";
194 String finalname = d.getPdpPolicyName(name, scope);
195 Assert.assertEquals(expectedFinalname, finalname);
199 public void getPolicySubFileTest() {
200 String name = "Config_testname.1.json";
201 String subFileType = "Config";
202 HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
204 Path path = handle.getPolicySubFile(name, subFileType);
205 Assert.assertNull(path);
209 public void createFromPolicyObject() {
210 Policy policyObject = new ConfigPolicy();
211 policyObject.policyAdapter = new PolicyRestAdapter();
212 policyObject.policyAdapter.setConfigName("testpolicy1");
213 policyObject.policyAdapter.setPolicyDescription("my description");
214 policyObject.policyAdapter.setConfigBodyData("this is my test config file");
215 policyObject.policyAdapter.setPolicyName("SampleTest1206");
216 policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
217 policyObject.policyAdapter.setPolicyType("Config");
218 policyObject.policyAdapter.setDomainDir("com");
219 policyObject.policyAdapter.setVersion("1");
220 policyObject.policyAdapter.setHighestVersion(1);
221 PolicyType policyTypeObject = new PolicyType();
222 policyObject.policyAdapter.setPolicyData(policyTypeObject);
223 ClassLoader classLoader = getClass().getClassLoader();
224 PolicyType policyConfig = new PolicyType();
225 policyConfig.setVersion("1");
226 policyConfig.setPolicyId("");
227 policyConfig.setTarget(new TargetType());
228 policyObject.policyAdapter.setData(policyConfig);
230 policyObject.policyAdapter
231 .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
232 } catch (Exception e2) {
236 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
238 transaction.createPolicy(policyObject, "testuser1");
239 transaction.commitTransaction();
240 } catch (Exception e) {
241 transaction.rollbackTransaction();
245 Session session = sessionFactory.openSession();
246 session.getTransaction().begin();
248 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
250 policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
251 policyQuery.setParameter("scope", "com");
253 List<?> policyQueryList = policyQuery.list();
254 PolicyEntity result = null;
256 result = (PolicyEntity) policyQueryList.get(0);
257 } catch (Exception e) {
258 logger.error("Exception Occured " + e);
261 session.getTransaction().commit();
266 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
267 } catch (IOException e1) {
270 Assert.assertEquals(expectedData, result.getPolicyData());
273 Assert.assertFalse(transaction.isTransactionOpen());
277 public void groupTransactions() {
278 PolicyDBDaoTransaction group = dbd.getNewTransaction();
279 String groupName = "test group 1";
281 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
283 group.commitTransaction();
284 } catch (Exception e) {
285 group.rollbackTransaction();
286 logger.error("Exception Occured" + e);
289 Session session = sessionFactory.openSession();
290 session.getTransaction().begin();
292 session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
293 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
294 getGroup.setParameter("deleted", false);
295 List<?> groups = getGroup.list();
296 GroupEntity groupEntity = (GroupEntity) groups.get(0);
297 Assert.assertEquals(groupName, groupEntity.getgroupName());
298 Assert.assertEquals("this is a test group", groupEntity.getDescription());
299 session.getTransaction().commit();
302 group = dbd.getNewTransaction();
304 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
305 group.deleteGroup(groupToDelete, null, "testuser");
306 group.commitTransaction();
307 } catch (Exception e) {
308 group.rollbackTransaction();
309 logger.error("Exception Occured" + e);
312 Session session2 = sessionFactory.openSession();
313 session2.getTransaction().begin();
315 session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
316 getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
317 getGroup2.setParameter("deleted", false);
318 List<?> groups2 = getGroup2.list();
319 groups2 = getGroup2.list();
320 if (groups2.size() != 0) {
321 System.out.println("Group size: " + groups2.size());
324 session2.getTransaction().commit();
328 // add a pdp to a group
329 group = dbd.getNewTransaction();
331 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
332 group.commitTransaction();
333 } catch (Exception e) {
334 group.rollbackTransaction();
335 logger.error("Exception Occured" + e);
339 group = dbd.getNewTransaction();
341 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary",
342 "the main pdp", 3232, "testuser");
343 group.commitTransaction();
344 } catch (Exception e) {
345 group.rollbackTransaction();
346 logger.error("Exception Occured" + e);
350 Session session3 = sessionFactory.openSession();
351 session3.getTransaction().begin();
352 Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
353 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
354 getPdp.setParameter("deleted", false);
355 List<?> pdps = getPdp.list();
356 if (pdps.size() != 1) {
357 System.out.println("Group size: " + pdps.size());
360 PdpEntity pdp = (PdpEntity) pdps.get(0);
361 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
362 Assert.assertEquals(pdp.getPdpName(), "primary");
363 session3.getTransaction().commit();
367 group = dbd.getNewTransaction();
369 group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
370 group.commitTransaction();
371 } catch (Exception e) {
372 group.rollbackTransaction();
373 logger.error("Exception Occured" + e);
377 Session session4 = sessionFactory.openSession();
378 session4.getTransaction().begin();
379 Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
380 getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
381 getPdp2.setParameter("deleted", false);
382 List<?> pdps2 = getPdp2.list();
383 if (pdps2.size() != 0) {
384 System.out.println("Group size: " + pdps2.size());
388 session4.getTransaction().commit();
391 // add some pdps to groups
392 group = dbd.getNewTransaction();
394 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
395 group.commitTransaction();
396 } catch (Exception e) {
397 group.rollbackTransaction();
398 logger.error("Exception Occured" + e);
401 group = dbd.getNewTransaction();
403 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
404 group.commitTransaction();
405 } catch (Exception e) {
406 group.rollbackTransaction();
407 logger.error("Exception Occured" + e);
411 group = dbd.getNewTransaction();
413 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
414 "the main pdp", 3232, "testuser");
415 group.commitTransaction();
416 } catch (Exception e) {
417 group.rollbackTransaction();
418 logger.error("Exception Occured" + e);
421 group = dbd.getNewTransaction();
423 group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
424 "secondary", "the second pdp", 3233, "testuser");
425 group.commitTransaction();
426 } catch (Exception e) {
427 group.rollbackTransaction();
428 logger.error("Exception Occured" + e);
432 Session session5 = sessionFactory.openSession();
433 session5.getTransaction().begin();
434 Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
435 getPdp3.setParameter("deleted", false);
436 List<?> pdps3 = getPdp3.list();
437 for (Object obj : pdps3) {
438 Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
441 session5.getTransaction().commit();
445 group = dbd.getNewTransaction();
447 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), Paths.get("/"));
448 OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
449 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
450 group.commitTransaction();
451 } catch (Exception e) {
452 group.rollbackTransaction();
453 logger.error("Exception Occured" + e);
457 Session session6 = sessionFactory.openSession();
458 session6.getTransaction().begin();
460 session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
461 getGroup3.setParameter("groupId", "testgroup1");
462 getGroup3.setParameter("deleted", false);
463 List<?> groups3 = getGroup3.list();
464 if (groups3.size() != 0) {
465 System.out.println("Group size: " + groups3.size());
469 session6.getTransaction().commit();
472 Session session7 = sessionFactory.openSession();
473 session7.getTransaction().begin();
474 Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
475 getPdp4.setParameter("deleted", false);
476 List<?> pdps4 = getPdp4.list();
477 for (Object obj : pdps4) {
478 Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getgroupName());
481 session7.getTransaction().commit();
485 group = dbd.getNewTransaction();
487 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
488 OnapPDPGroup groupToMoveTo = null;
489 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
490 group.commitTransaction();
492 } catch (PolicyDBException pe) {
493 // good, can't delete group with pdps
494 group.rollbackTransaction();
495 } catch (Exception e) {
496 group.rollbackTransaction();
497 logger.error("Exception Occured" + e);
502 OnapPDPGroup pdpGroup =
503 new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
504 group = dbd.getNewTransaction();
506 group.updateGroup(pdpGroup, "testuser", "testuser");
507 group.commitTransaction();
508 } catch (Exception e) {
509 logger.error("Exception Occured" + e);
510 group.rollbackTransaction();
514 Session session8 = sessionFactory.openSession();
515 session8.getTransaction().begin();
517 session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
518 getGroup4.setParameter("groupId", "newtestgroup2");
519 getGroup4.setParameter("deleted", false);
520 List<?> groups4 = getGroup4.list();
521 if (groups4.size() != 1) {
522 System.out.println("Group size: " + groups4.size());
526 session8.getTransaction().commit();
529 Session session9 = sessionFactory.openSession();
530 session9.getTransaction().begin();
532 session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
533 getGroup5.setParameter("groupId", "testgroup2");
534 getGroup5.setParameter("deleted", false);
535 List<?> groups5 = getGroup5.list();
536 if (groups5.size() != 0) {
537 System.out.println("Group size: " + groups5.size());
541 session9.getTransaction().commit();
547 public void threadingStabilityTest() {
548 if (logger.isDebugEnabled()) {
549 logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
550 + "******************************\n\n");
553 PolicyDBDaoTransaction t = dbd.getNewTransaction();
554 Assert.assertTrue(t.isTransactionOpen());
556 // Add 1000 ms to the timeout just to be sure it actually times out
558 Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
559 if (logger.isDebugEnabled()) {
560 Date date = new java.util.Date();
561 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
562 + "\n TimeStamp = " + date.getTime() + "\n\n");
564 Thread.sleep(sleepTime);
565 } catch (InterruptedException e) {
566 logger.error("Exception Occured" + e);
568 if (logger.isDebugEnabled()) {
569 Date date = new java.util.Date();
571 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(t.isTransactionOpen() = "
572 + t.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
574 Assert.assertFalse(t.isTransactionOpen());
577 if (logger.isDebugEnabled()) {
578 Date date = new java.util.Date();
579 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n a = dbd.getNewTransaction() "
580 + "\n TimeStamp = " + date.getTime() + "\n\n");
582 PolicyDBDaoTransaction a = dbd.getNewTransaction();
583 if (logger.isDebugEnabled()) {
584 Date date = new java.util.Date();
586 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
587 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
589 Assert.assertTrue(a.isTransactionOpen());
592 // Add 1000 ms to the timeout just to be sure it actually times out
594 Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
595 if (logger.isDebugEnabled()) {
596 Date date = new java.util.Date();
597 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
598 + "\n TimeStamp = " + date.getTime() + "\n\n");
600 Thread.sleep(sleepTime);
601 } catch (InterruptedException e) {
602 logger.error("Exception Occured" + e);
604 if (logger.isDebugEnabled()) {
605 Date date = new java.util.Date();
606 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n b = dbd.getNewTransaction() "
607 + "\n TimeStamp = " + date.getTime() + "\n\n");
609 PolicyDBDaoTransaction b = dbd.getNewTransaction();
610 if (logger.isDebugEnabled()) {
611 Date date = new java.util.Date();
613 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
614 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
616 Assert.assertFalse(a.isTransactionOpen());
617 if (logger.isDebugEnabled()) {
618 Date date = new java.util.Date();
620 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
621 + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
623 Assert.assertTrue(b.isTransactionOpen());
628 // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
629 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT, "1000");
630 // And let's lengthen the transaction timeout to 5000 ms
631 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
633 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
634 if (logger.isDebugEnabled()) {
635 Date date = new java.util.Date();
637 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
638 + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
640 Assert.assertTrue(t1.isTransactionOpen());
641 // while it is open, get another from a different DB Dao so it will not collide on the synchronized
643 // but will collide at the DB. Remember that the wait time is only 1000 ms
645 // Now the 2nd transaction has a wait timeout in 1000 ms
646 PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
648 * Give it plenty of time to time out the second transaction It will actually hang right here until
649 * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
650 * sloppy so, I have given this plenty of leeway.
653 if (logger.isDebugEnabled()) {
654 Date date = new java.util.Date();
655 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Thread.sleep(3000)"
656 + "\n TimeStamp = " + date.getTime() + "\n\n");
659 if (logger.isDebugEnabled()) {
660 Date date = new java.util.Date();
661 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
662 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
663 + "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
664 + "\n TimeStamp = " + date.getTime() + "\n\n");
666 // Assert.assertTrue(t1.isTransactionOpen());
667 // Assert.assertFalse(t2.isTransactionOpen());
669 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
670 } catch (PersistenceException e) {
672 if (logger.isDebugEnabled()) {
673 Date date = new java.util.Date();
674 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
675 + "\n SUCCESS! Transaction Wait Timeout worked!" + "\n Caught PersistenceException = " + e
676 + "\n TimeStamp = " + date.getTime() + "\n\n");
678 } catch (Exception e) {
679 // failure due to some other reason
680 if (logger.isDebugEnabled()) {
681 Date date = new java.util.Date();
682 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n Caught Exception = " + e
683 + "\n TimeStamp = " + date.getTime() + "\n\n");
685 logger.error("Exception Occured" + e);
689 if (logger.isDebugEnabled()) {
690 Date date = new java.util.Date();
691 logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");