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 org.apache.commons.io.FileUtils;
35 import org.apache.commons.io.IOUtils;
36 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
37 import org.hibernate.Query;
38 import org.hibernate.Session;
39 import org.hibernate.SessionFactory;
40 import org.junit.After;
41 import org.junit.Assert;
42 import org.junit.BeforeClass;
43 import org.junit.Ignore;
44 import org.junit.Test;
45 import org.onap.policy.common.logging.flexlogger.FlexLogger;
46 import org.onap.policy.common.logging.flexlogger.Logger;
47 import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
48 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
49 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
50 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
51 import org.onap.policy.rest.XACMLRestProperties;
52 import org.onap.policy.rest.adapter.PolicyRestAdapter;
53 import org.onap.policy.rest.dao.PolicyDBException;
54 import org.onap.policy.rest.jpa.DatabaseLockEntity;
55 import org.onap.policy.rest.jpa.GroupEntity;
56 import org.onap.policy.rest.jpa.PdpEntity;
57 import org.onap.policy.rest.jpa.PolicyEntity;
58 import org.onap.policy.rest.jpa.UserInfo;
59 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
60 import org.onap.policy.xacml.std.pap.StdEngine;
61 import org.onap.policy.xacml.std.pap.StdPDPGroup;
62 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
63 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
64 import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
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 new PolicyDbDaoTransactionInstance(sessionFac).isJunit = true;
123 CommonClassDaoImpl.setSessionfactory(sessionFac);
124 new DataToNotifyPdp(new CommonClassDaoImpl());
125 PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
127 DatabaseLockEntity lock = null;
128 Session session = sessionFac.openSession();
129 session.getTransaction().begin();
130 lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
132 lock = new DatabaseLockEntity();
134 session.persist(lock);
137 session.getTransaction().commit();
140 UserInfo user = new UserInfo();
141 user.setUserLoginId("API");
142 user.setUserName("API");
143 Session session2 = sessionFac.openSession();
144 session2.getTransaction().begin();
145 session2.persist(user);
147 session2.getTransaction().commit();
155 public void testGetConfigFile() {
156 PolicyRestAdapter pra = new PolicyRestAdapter();
157 pra.setConfigType(ConfigPolicy.JSON_CONFIG);
158 String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
159 Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
160 // yes, we can do action files too even though they don't have configs
161 configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
162 Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
166 public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
167 String policyName = "com.Decision_testname.1.xml";
168 String[] expectedNameAndVersion = new String[2];
169 expectedNameAndVersion[0] = "com.Decision_testname";
170 expectedNameAndVersion[1] = "1";
171 String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
172 Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
176 public void getNameScopeAndVersionFromPdpPolicyTest() {
177 String fileName = "com.Decision_testname.1.xml";
178 String[] expectedArray = new String[3];
179 expectedArray[0] = "Decision_testname.1.xml";
180 expectedArray[2] = "1";
181 expectedArray[1] = "com";
183 String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
184 Assert.assertArrayEquals(expectedArray, returnArray);
188 public void getPdpPolicyNameTest() {
189 String name = "Decision_testname.1.json";
190 String scope = "com";
191 String expectedFinalname = "com.Decision_testname.1.xml";
193 String finalname = d.getPdpPolicyName(name, scope);
194 Assert.assertEquals(expectedFinalname, finalname);
198 public void getPolicySubFileTest() {
199 String name = "Config_testname.1.json";
200 String subFileType = "Config";
201 HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
203 Path path = handle.getPolicySubFile(name, subFileType);
204 Assert.assertNull(path);
208 public void createFromPolicyObject() {
209 Policy policyObject = new ConfigPolicy();
210 policyObject.policyAdapter = new PolicyRestAdapter();
211 policyObject.policyAdapter.setConfigName("testpolicy1");
212 policyObject.policyAdapter.setPolicyDescription("my description");
213 policyObject.policyAdapter.setConfigBodyData("this is my test config file");
214 policyObject.policyAdapter.setPolicyName("SampleTest1206");
215 policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
216 policyObject.policyAdapter.setPolicyType("Config");
217 policyObject.policyAdapter.setDomainDir("com");
218 policyObject.policyAdapter.setVersion("1");
219 policyObject.policyAdapter.setHighestVersion(1);
220 PolicyType policyTypeObject = new PolicyType();
221 policyObject.policyAdapter.setPolicyData(policyTypeObject);
222 ClassLoader classLoader = getClass().getClassLoader();
223 PolicyType policyConfig = new PolicyType();
224 policyConfig.setVersion("1");
225 policyConfig.setPolicyId("");
226 policyConfig.setTarget(new TargetType());
227 policyObject.policyAdapter.setData(policyConfig);
229 policyObject.policyAdapter
230 .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
231 } catch (Exception e2) {
235 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
237 transaction.createPolicy(policyObject, "testuser1");
238 transaction.commitTransaction();
239 } catch (Exception e) {
240 transaction.rollbackTransaction();
244 Session session = sessionFactory.openSession();
245 session.getTransaction().begin();
247 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
249 policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
250 policyQuery.setParameter("scope", "com");
252 List<?> policyQueryList = policyQuery.list();
253 PolicyEntity result = null;
255 result = (PolicyEntity) policyQueryList.get(0);
256 } catch (Exception e) {
257 logger.error("Exception Occured " + e);
260 session.getTransaction().commit();
265 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
266 } catch (IOException e1) {
269 Assert.assertEquals(expectedData, result.getPolicyData());
272 Assert.assertFalse(transaction.isTransactionOpen());
276 public void groupTransactions() {
277 PolicyDBDaoTransaction group = dbd.getNewTransaction();
278 String groupName = "test group 1";
280 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
282 group.commitTransaction();
283 } catch (Exception e) {
284 group.rollbackTransaction();
285 logger.error("Exception Occured" + e);
288 Session session = sessionFactory.openSession();
289 session.getTransaction().begin();
291 session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
292 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
293 getGroup.setParameter("deleted", false);
294 List<?> groups = getGroup.list();
295 GroupEntity groupEntity = (GroupEntity) groups.get(0);
296 Assert.assertEquals(groupName, groupEntity.getgroupName());
297 Assert.assertEquals("this is a test group", groupEntity.getDescription());
298 session.getTransaction().commit();
301 group = dbd.getNewTransaction();
303 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
304 group.deleteGroup(groupToDelete, null, "testuser");
305 group.commitTransaction();
306 } catch (Exception e) {
307 group.rollbackTransaction();
308 logger.error("Exception Occured" + e);
311 Session session2 = sessionFactory.openSession();
312 session2.getTransaction().begin();
314 session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
315 getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
316 getGroup2.setParameter("deleted", false);
317 List<?> groups2 = getGroup2.list();
318 groups2 = getGroup2.list();
319 if (groups2.size() != 0) {
320 System.out.println("Group size: " + groups2.size());
323 session2.getTransaction().commit();
327 // add a pdp to a group
328 group = dbd.getNewTransaction();
330 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
331 group.commitTransaction();
332 } catch (Exception e) {
333 group.rollbackTransaction();
334 logger.error("Exception Occured" + e);
338 group = dbd.getNewTransaction();
340 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary",
341 "the main pdp", 3232, "testuser");
342 group.commitTransaction();
343 } catch (Exception e) {
344 group.rollbackTransaction();
345 logger.error("Exception Occured" + e);
349 Session session3 = sessionFactory.openSession();
350 session3.getTransaction().begin();
351 Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
352 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
353 getPdp.setParameter("deleted", false);
354 List<?> pdps = getPdp.list();
355 if (pdps.size() != 1) {
356 System.out.println("Group size: " + pdps.size());
359 PdpEntity pdp = (PdpEntity) pdps.get(0);
360 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
361 Assert.assertEquals(pdp.getPdpName(), "primary");
362 session3.getTransaction().commit();
366 group = dbd.getNewTransaction();
368 group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
369 group.commitTransaction();
370 } catch (Exception e) {
371 group.rollbackTransaction();
372 logger.error("Exception Occured" + e);
376 Session session4 = sessionFactory.openSession();
377 session4.getTransaction().begin();
378 Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
379 getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
380 getPdp2.setParameter("deleted", false);
381 List<?> pdps2 = getPdp2.list();
382 if (pdps2.size() != 0) {
383 System.out.println("Group size: " + pdps2.size());
387 session4.getTransaction().commit();
390 // add some pdps to groups
391 group = dbd.getNewTransaction();
393 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
394 group.commitTransaction();
395 } catch (Exception e) {
396 group.rollbackTransaction();
397 logger.error("Exception Occured" + e);
400 group = dbd.getNewTransaction();
402 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
403 group.commitTransaction();
404 } catch (Exception e) {
405 group.rollbackTransaction();
406 logger.error("Exception Occured" + e);
410 group = dbd.getNewTransaction();
412 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
413 "the main pdp", 3232, "testuser");
414 group.commitTransaction();
415 } catch (Exception e) {
416 group.rollbackTransaction();
417 logger.error("Exception Occured" + e);
420 group = dbd.getNewTransaction();
422 group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
423 "secondary", "the second pdp", 3233, "testuser");
424 group.commitTransaction();
425 } catch (Exception e) {
426 group.rollbackTransaction();
427 logger.error("Exception Occured" + e);
431 Session session5 = sessionFactory.openSession();
432 session5.getTransaction().begin();
433 Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
434 getPdp3.setParameter("deleted", false);
435 List<?> pdps3 = getPdp3.list();
436 for (Object obj : pdps3) {
437 Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
440 session5.getTransaction().commit();
444 group = dbd.getNewTransaction();
446 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), Paths.get("/"));
447 OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
448 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
449 group.commitTransaction();
450 } catch (Exception e) {
451 group.rollbackTransaction();
452 logger.error("Exception Occured" + e);
456 Session session6 = sessionFactory.openSession();
457 session6.getTransaction().begin();
459 session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
460 getGroup3.setParameter("groupId", "testgroup1");
461 getGroup3.setParameter("deleted", false);
462 List<?> groups3 = getGroup3.list();
463 if (groups3.size() != 0) {
464 System.out.println("Group size: " + groups3.size());
468 session6.getTransaction().commit();
471 Session session7 = sessionFactory.openSession();
472 session7.getTransaction().begin();
473 Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
474 getPdp4.setParameter("deleted", false);
475 List<?> pdps4 = getPdp4.list();
476 for (Object obj : pdps4) {
477 Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getgroupName());
480 session7.getTransaction().commit();
484 group = dbd.getNewTransaction();
486 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
487 OnapPDPGroup groupToMoveTo = null;
488 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
489 group.commitTransaction();
491 } catch (PolicyDBException pe) {
492 // good, can't delete group with pdps
493 group.rollbackTransaction();
494 } catch (Exception e) {
495 group.rollbackTransaction();
496 logger.error("Exception Occured" + e);
501 OnapPDPGroup pdpGroup =
502 new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
503 group = dbd.getNewTransaction();
505 group.updateGroup(pdpGroup, "testuser", "testuser");
506 group.commitTransaction();
507 } catch (Exception e) {
508 logger.error("Exception Occured" + e);
509 group.rollbackTransaction();
513 Session session8 = sessionFactory.openSession();
514 session8.getTransaction().begin();
516 session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
517 getGroup4.setParameter("groupId", "newtestgroup2");
518 getGroup4.setParameter("deleted", false);
519 List<?> groups4 = getGroup4.list();
520 if (groups4.size() != 1) {
521 System.out.println("Group size: " + groups4.size());
525 session8.getTransaction().commit();
528 Session session9 = sessionFactory.openSession();
529 session9.getTransaction().begin();
531 session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
532 getGroup5.setParameter("groupId", "testgroup2");
533 getGroup5.setParameter("deleted", false);
534 List<?> groups5 = getGroup5.list();
535 if (groups5.size() != 0) {
536 System.out.println("Group size: " + groups5.size());
540 session9.getTransaction().commit();
546 public void threadingStabilityTest() {
547 if (logger.isDebugEnabled()) {
548 logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
549 + "******************************\n\n");
552 PolicyDBDaoTransaction t = dbd.getNewTransaction();
553 Assert.assertTrue(t.isTransactionOpen());
555 // Add 1000 ms to the timeout just to be sure it actually times out
557 Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
558 if (logger.isDebugEnabled()) {
559 Date date = new java.util.Date();
560 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
561 + "\n TimeStamp = " + date.getTime() + "\n\n");
563 Thread.sleep(sleepTime);
564 } catch (InterruptedException e) {
565 logger.error("Exception Occured" + e);
567 if (logger.isDebugEnabled()) {
568 Date date = new java.util.Date();
570 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(t.isTransactionOpen() = "
571 + t.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
573 Assert.assertFalse(t.isTransactionOpen());
576 if (logger.isDebugEnabled()) {
577 Date date = new java.util.Date();
578 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n a = dbd.getNewTransaction() "
579 + "\n TimeStamp = " + date.getTime() + "\n\n");
581 PolicyDBDaoTransaction a = dbd.getNewTransaction();
582 if (logger.isDebugEnabled()) {
583 Date date = new java.util.Date();
585 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
586 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
588 Assert.assertTrue(a.isTransactionOpen());
591 // Add 1000 ms to the timeout just to be sure it actually times out
593 Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
594 if (logger.isDebugEnabled()) {
595 Date date = new java.util.Date();
596 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
597 + "\n TimeStamp = " + date.getTime() + "\n\n");
599 Thread.sleep(sleepTime);
600 } catch (InterruptedException e) {
601 logger.error("Exception Occured" + e);
603 if (logger.isDebugEnabled()) {
604 Date date = new java.util.Date();
605 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n b = dbd.getNewTransaction() "
606 + "\n TimeStamp = " + date.getTime() + "\n\n");
608 PolicyDBDaoTransaction b = dbd.getNewTransaction();
609 if (logger.isDebugEnabled()) {
610 Date date = new java.util.Date();
612 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
613 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
615 Assert.assertFalse(a.isTransactionOpen());
616 if (logger.isDebugEnabled()) {
617 Date date = new java.util.Date();
619 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
620 + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
622 Assert.assertTrue(b.isTransactionOpen());
627 // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
628 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT, "1000");
629 // And let's lengthen the transaction timeout to 5000 ms
630 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
632 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
633 if (logger.isDebugEnabled()) {
634 Date date = new java.util.Date();
636 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
637 + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
639 Assert.assertTrue(t1.isTransactionOpen());
640 // while it is open, get another from a different DB Dao so it will not collide on the synchronized
642 // but will collide at the DB. Remember that the wait time is only 1000 ms
644 // Now the 2nd transaction has a wait timeout in 1000 ms
645 PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
647 * Give it plenty of time to time out the second transaction It will actually hang right here until
648 * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
649 * sloppy so, I have given this plenty of leeway.
652 if (logger.isDebugEnabled()) {
653 Date date = new java.util.Date();
654 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Thread.sleep(3000)"
655 + "\n TimeStamp = " + date.getTime() + "\n\n");
658 if (logger.isDebugEnabled()) {
659 Date date = new java.util.Date();
660 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
661 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
662 + "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
663 + "\n TimeStamp = " + date.getTime() + "\n\n");
665 // Assert.assertTrue(t1.isTransactionOpen());
666 // Assert.assertFalse(t2.isTransactionOpen());
668 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
669 } catch (PersistenceException e) {
671 if (logger.isDebugEnabled()) {
672 Date date = new java.util.Date();
673 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
674 + "\n SUCCESS! Transaction Wait Timeout worked!" + "\n Caught PersistenceException = " + e
675 + "\n TimeStamp = " + date.getTime() + "\n\n");
677 } catch (Exception e) {
678 // failure due to some other reason
679 if (logger.isDebugEnabled()) {
680 Date date = new java.util.Date();
681 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n Caught Exception = " + e
682 + "\n TimeStamp = " + date.getTime() + "\n\n");
684 logger.error("Exception Occured" + e);
688 if (logger.isDebugEnabled()) {
689 Date date = new java.util.Date();
690 logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");