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;
25 import com.att.research.xacml.api.pap.PAPException;
26 import com.att.research.xacml.util.XACMLProperties;
29 import java.io.IOException;
30 import java.nio.file.Path;
31 import java.nio.file.Paths;
32 import java.util.Date;
33 import java.util.List;
34 import java.util.Properties;
35 import javax.persistence.Persistence;
36 import javax.persistence.PersistenceException;
38 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
39 import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
41 import org.apache.commons.io.FileUtils;
42 import org.apache.commons.io.IOUtils;
43 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
44 import org.hibernate.Query;
45 import org.hibernate.Session;
46 import org.hibernate.SessionFactory;
47 import org.junit.After;
48 import org.junit.Assert;
49 import org.junit.BeforeClass;
50 import org.junit.Ignore;
51 import org.junit.Test;
52 import org.onap.policy.common.logging.flexlogger.FlexLogger;
53 import org.onap.policy.common.logging.flexlogger.Logger;
54 import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
55 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
56 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
57 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
58 import org.onap.policy.rest.XacmlRestProperties;
59 import org.onap.policy.rest.adapter.PolicyRestAdapter;
60 import org.onap.policy.rest.dao.PolicyDBException;
61 import org.onap.policy.rest.jpa.DatabaseLockEntity;
62 import org.onap.policy.rest.jpa.GroupEntity;
63 import org.onap.policy.rest.jpa.PdpEntity;
64 import org.onap.policy.rest.jpa.PolicyEntity;
65 import org.onap.policy.rest.jpa.UserInfo;
66 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
67 import org.onap.policy.xacml.std.pap.StdEngine;
68 import org.onap.policy.xacml.std.pap.StdPDPGroup;
69 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
71 public class PolicyDBDaoTest {
72 private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
74 static PolicyDBDaoTestClass d;
75 static PolicyDBDao dbd;
76 static PolicyDBDao dbd2;
77 private static Path repository;
78 static StdEngine stdEngine = null;
79 static SessionFactory sessionFactory = null;
82 public static void init() throws PAPException, IOException {
83 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
85 sessionFactory = setupH2DbDaoImpl("testdbdao");
86 dbd = PolicyDBDao.getPolicyDBDaoInstance();
87 dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
88 } catch (Exception e) {
92 d = PolicyDBDao.getPolicyDBDaoTestClass();
93 PolicyDBDao.setJunit(true);
94 repository = Paths.get("src/test/resources/pdps");
95 stdEngine = new StdEngine(repository);
96 dbd.setPapEngine(stdEngine);
100 public void cleanUp() {
102 FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
103 } catch (IOException e) {
108 public static SessionFactory setupH2DbDaoImpl(String dbName) {
111 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
112 BasicDataSource dataSource = new BasicDataSource();
113 dataSource.setDriverClassName("org.h2.Driver");
114 dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
115 dataSource.setUsername("sa");
116 dataSource.setPassword("");
117 LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
118 sessionBuilder.scanPackages("org.onap.*");
120 Properties properties = new Properties();
121 properties.put("hibernate.show_sql", "false");
122 properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
123 properties.put("hibernate.hbm2ddl.auto", "create-drop");
125 sessionBuilder.addProperties(properties);
126 SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
128 new PolicyDBDao(sessionFac);
129 PolicyDbDaoTransactionInstance.setJunit(true);
130 new PolicyDbDaoTransactionInstance(sessionFac);
131 CommonClassDaoImpl.setSessionfactory(sessionFac);
132 new DataToNotifyPdp(new CommonClassDaoImpl());
133 PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
135 DatabaseLockEntity lock = null;
136 Session session = sessionFac.openSession();
137 session.getTransaction().begin();
138 lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
140 lock = new DatabaseLockEntity();
142 session.persist(lock);
145 session.getTransaction().commit();
148 UserInfo user = new UserInfo();
149 user.setUserLoginId("API");
150 user.setUserName("API");
151 Session session2 = sessionFac.openSession();
152 session2.getTransaction().begin();
153 session2.persist(user);
155 session2.getTransaction().commit();
161 private static void setUpAuditDb() {
162 Properties properties = new Properties();
163 properties.put(XacmlRestProperties.PROP_PAP_DB_DRIVER, "org.h2.Driver");
164 properties.put(XacmlRestProperties.PROP_PAP_DB_URL, "jdbc:h2:file:./sql/xacmlTest");
165 properties.put(XacmlRestProperties.PROP_PAP_DB_USER, "sa");
166 properties.put(XacmlRestProperties.PROP_PAP_DB_PASSWORD, "");
168 // create the DB and then close it
169 Persistence.createEntityManagerFactory("testPapPU", properties).close();
173 public void testGetConfigFile() {
174 PolicyRestAdapter pra = new PolicyRestAdapter();
175 pra.setConfigType(ConfigPolicy.JSON_CONFIG);
176 String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
177 Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
178 // yes, we can do action files too even though they don't have configs
179 configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
180 Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
184 public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
185 String policyName = "com.Decision_testname.1.xml";
186 String[] expectedNameAndVersion = new String[2];
187 expectedNameAndVersion[0] = "com.Decision_testname";
188 expectedNameAndVersion[1] = "1";
189 String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
190 Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
194 public void getNameScopeAndVersionFromPdpPolicyTest() {
195 String fileName = "com.Decision_testname.1.xml";
196 String[] expectedArray = new String[3];
197 expectedArray[0] = "Decision_testname.1.xml";
198 expectedArray[2] = "1";
199 expectedArray[1] = "com";
201 String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
202 Assert.assertArrayEquals(expectedArray, returnArray);
206 public void getPdpPolicyNameTest() {
207 String name = "Decision_testname.1.json";
208 String scope = "com";
209 String expectedFinalname = "com.Decision_testname.1.xml";
211 String finalname = d.getPdpPolicyName(name, scope);
212 Assert.assertEquals(expectedFinalname, finalname);
216 public void getPolicySubFileTest() {
217 String name = "Config_testname.1.json";
218 String subFileType = "Config";
219 HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
221 Path path = handle.getPolicySubFile(name, subFileType);
222 Assert.assertNull(path);
226 public void createFromPolicyObject() {
227 Policy policyObject = new ConfigPolicy();
228 policyObject.policyAdapter = new PolicyRestAdapter();
229 policyObject.policyAdapter.setConfigName("testpolicy1");
230 policyObject.policyAdapter.setPolicyDescription("my description");
231 policyObject.policyAdapter.setConfigBodyData("this is my test config file");
232 policyObject.policyAdapter.setPolicyName("SampleTest1206");
233 policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
234 policyObject.policyAdapter.setPolicyType("Config");
235 policyObject.policyAdapter.setDomainDir("com");
236 policyObject.policyAdapter.setVersion("1");
237 policyObject.policyAdapter.setHighestVersion(1);
238 PolicyType policyTypeObject = new PolicyType();
239 policyObject.policyAdapter.setPolicyData(policyTypeObject);
240 ClassLoader classLoader = getClass().getClassLoader();
241 PolicyType policyConfig = new PolicyType();
242 policyConfig.setVersion("1");
243 policyConfig.setPolicyId("");
244 policyConfig.setTarget(new TargetType());
245 policyObject.policyAdapter.setData(policyConfig);
247 policyObject.policyAdapter
248 .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
249 } catch (Exception e2) {
253 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
255 transaction.createPolicy(policyObject, "testuser1");
256 transaction.commitTransaction();
257 } catch (Exception e) {
258 transaction.rollbackTransaction();
262 Session session = sessionFactory.openSession();
263 session.getTransaction().begin();
265 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
267 policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
268 policyQuery.setParameter("scope", "com");
270 List<?> policyQueryList = policyQuery.list();
271 PolicyEntity result = null;
273 result = (PolicyEntity) policyQueryList.get(0);
274 } catch (Exception e) {
275 logger.error("Exception Occured " + e);
278 session.getTransaction().commit();
283 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
284 } catch (IOException e1) {
287 Assert.assertEquals(expectedData, result.getPolicyData());
290 Assert.assertFalse(transaction.isTransactionOpen());
294 public void groupTransactions() {
295 PolicyDBDaoTransaction group = dbd.getNewTransaction();
296 String groupName = "test group 1";
298 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
300 group.commitTransaction();
301 } catch (Exception e) {
302 group.rollbackTransaction();
303 logger.error("Exception Occured" + e);
306 Session session = sessionFactory.openSession();
307 session.getTransaction().begin();
309 session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
310 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
311 getGroup.setParameter("deleted", false);
312 List<?> groups = getGroup.list();
313 GroupEntity groupEntity = (GroupEntity) groups.get(0);
314 Assert.assertEquals(groupName, groupEntity.getgroupName());
315 Assert.assertEquals("this is a test group", groupEntity.getDescription());
316 session.getTransaction().commit();
319 group = dbd.getNewTransaction();
321 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
322 group.deleteGroup(groupToDelete, null, "testuser");
323 group.commitTransaction();
324 } catch (Exception e) {
325 group.rollbackTransaction();
326 logger.error("Exception Occured" + e);
329 Session session2 = sessionFactory.openSession();
330 session2.getTransaction().begin();
332 session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
333 getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
334 getGroup2.setParameter("deleted", false);
335 List<?> groups2 = getGroup2.list();
336 groups2 = getGroup2.list();
337 if (groups2.size() != 0) {
338 System.out.println("Group size: " + groups2.size());
341 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();
382 group = dbd.getNewTransaction();
384 group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
385 group.commitTransaction();
386 } catch (Exception e) {
387 group.rollbackTransaction();
388 logger.error("Exception Occured" + e);
392 Session session4 = sessionFactory.openSession();
393 session4.getTransaction().begin();
394 Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
395 getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
396 getPdp2.setParameter("deleted", false);
397 List<?> pdps2 = getPdp2.list();
398 if (pdps2.size() != 0) {
399 System.out.println("Group size: " + pdps2.size());
403 session4.getTransaction().commit();
406 // add some pdps to groups
407 group = dbd.getNewTransaction();
409 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
410 group.commitTransaction();
411 } catch (Exception e) {
412 group.rollbackTransaction();
413 logger.error("Exception Occured" + e);
416 group = dbd.getNewTransaction();
418 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
419 group.commitTransaction();
420 } catch (Exception e) {
421 group.rollbackTransaction();
422 logger.error("Exception Occured" + e);
426 group = dbd.getNewTransaction();
428 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
429 "the main pdp", 3232, "testuser");
430 group.commitTransaction();
431 } catch (Exception e) {
432 group.rollbackTransaction();
433 logger.error("Exception Occured" + e);
436 group = dbd.getNewTransaction();
438 group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
439 "secondary", "the second pdp", 3233, "testuser");
440 group.commitTransaction();
441 } catch (Exception e) {
442 group.rollbackTransaction();
443 logger.error("Exception Occured" + e);
447 Session session5 = sessionFactory.openSession();
448 session5.getTransaction().begin();
449 Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
450 getPdp3.setParameter("deleted", false);
451 List<?> pdps3 = getPdp3.list();
452 for (Object obj : pdps3) {
453 Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
456 session5.getTransaction().commit();
459 group = dbd.getNewTransaction();
461 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), Paths.get("/"));
462 OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
463 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
464 group.commitTransaction();
465 } catch (Exception e) {
466 group.rollbackTransaction();
467 logger.error("Exception Occured" + e);
471 Session session6 = sessionFactory.openSession();
472 session6.getTransaction().begin();
474 session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
475 getGroup3.setParameter("groupId", "testgroup1");
476 getGroup3.setParameter("deleted", false);
477 List<?> groups3 = getGroup3.list();
478 if (groups3.size() != 0) {
479 System.out.println("Group size: " + groups3.size());
483 session6.getTransaction().commit();
486 Session session7 = sessionFactory.openSession();
487 session7.getTransaction().begin();
488 Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
489 getPdp4.setParameter("deleted", false);
490 List<?> pdps4 = getPdp4.list();
491 for (Object obj : pdps4) {
492 Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getgroupName());
495 session7.getTransaction().commit();
498 group = dbd.getNewTransaction();
500 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
501 OnapPDPGroup groupToMoveTo = null;
502 group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
503 group.commitTransaction();
505 } catch (PolicyDBException pe) {
506 // good, can't delete group with pdps
507 group.rollbackTransaction();
508 } catch (Exception e) {
509 group.rollbackTransaction();
510 logger.error("Exception Occured" + e);
515 OnapPDPGroup pdpGroup =
516 new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
517 group = dbd.getNewTransaction();
519 group.updateGroup(pdpGroup, "testuser", "testuser");
520 group.commitTransaction();
521 } catch (Exception e) {
522 logger.error("Exception Occured" + e);
523 group.rollbackTransaction();
527 Session session8 = sessionFactory.openSession();
528 session8.getTransaction().begin();
530 session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
531 getGroup4.setParameter("groupId", "newtestgroup2");
532 getGroup4.setParameter("deleted", false);
533 List<?> groups4 = getGroup4.list();
534 if (groups4.size() != 1) {
535 System.out.println("Group size: " + groups4.size());
539 session8.getTransaction().commit();
542 Session session9 = sessionFactory.openSession();
543 session9.getTransaction().begin();
545 session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
546 getGroup5.setParameter("groupId", "testgroup2");
547 getGroup5.setParameter("deleted", false);
548 List<?> groups5 = getGroup5.list();
549 if (groups5.size() != 0) {
550 System.out.println("Group size: " + groups5.size());
554 session9.getTransaction().commit();
560 public void threadingStabilityTest() {
561 if (logger.isDebugEnabled()) {
562 logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
563 + "******************************\n\n");
566 PolicyDBDaoTransaction t = dbd.getNewTransaction();
567 Assert.assertTrue(t.isTransactionOpen());
569 // Add 1000 ms to the timeout just to be sure it actually times out
571 Integer.parseInt(XACMLProperties.getProperty(XacmlRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
572 if (logger.isDebugEnabled()) {
573 Date date = new java.util.Date();
574 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
575 + "\n TimeStamp = " + date.getTime() + "\n\n");
577 Thread.sleep(sleepTime);
578 } catch (InterruptedException e) {
579 logger.error("Exception Occured" + e);
581 if (logger.isDebugEnabled()) {
582 Date date = new java.util.Date();
584 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(t.isTransactionOpen() = "
585 + t.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
587 Assert.assertFalse(t.isTransactionOpen());
589 if (logger.isDebugEnabled()) {
590 Date date = new java.util.Date();
591 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n a = dbd.getNewTransaction() "
592 + "\n TimeStamp = " + date.getTime() + "\n\n");
594 PolicyDBDaoTransaction a = dbd.getNewTransaction();
595 if (logger.isDebugEnabled()) {
596 Date date = new java.util.Date();
598 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
599 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
601 Assert.assertTrue(a.isTransactionOpen());
604 // Add 1000 ms to the timeout just to be sure it actually times out
606 Integer.parseInt(XACMLProperties.getProperty(XacmlRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
607 if (logger.isDebugEnabled()) {
608 Date date = new java.util.Date();
609 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
610 + "\n TimeStamp = " + date.getTime() + "\n\n");
612 Thread.sleep(sleepTime);
613 } catch (InterruptedException e) {
614 logger.error("Exception Occured" + e);
616 if (logger.isDebugEnabled()) {
617 Date date = new java.util.Date();
618 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n b = dbd.getNewTransaction() "
619 + "\n TimeStamp = " + date.getTime() + "\n\n");
621 PolicyDBDaoTransaction b = dbd.getNewTransaction();
622 if (logger.isDebugEnabled()) {
623 Date date = new java.util.Date();
625 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
626 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
628 Assert.assertFalse(a.isTransactionOpen());
629 if (logger.isDebugEnabled()) {
630 Date date = new java.util.Date();
632 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
633 + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
635 Assert.assertTrue(b.isTransactionOpen());
638 // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
639 System.setProperty(XacmlRestProperties.PROP_PAP_TRANS_WAIT, "1000");
640 // And let's lengthen the transaction timeout to 5000 ms
641 System.setProperty(XacmlRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
643 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
644 if (logger.isDebugEnabled()) {
645 Date date = new java.util.Date();
647 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
648 + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
650 Assert.assertTrue(t1.isTransactionOpen());
651 // while it is open, get another from a different DB Dao so it will not collide on the synchronized
653 // but will collide at the DB. Remember that the wait time is only 1000 ms
655 // Now the 2nd transaction has a wait timeout in 1000 ms
656 PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
658 * Give it plenty of time to time out the second transaction It will actually hang right here until
659 * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
660 * sloppy so, I have given this plenty of leeway.
663 if (logger.isDebugEnabled()) {
664 Date date = new java.util.Date();
665 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Thread.sleep(3000)"
666 + "\n TimeStamp = " + date.getTime() + "\n\n");
669 if (logger.isDebugEnabled()) {
670 Date date = new java.util.Date();
671 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
672 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
673 + "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
674 + "\n TimeStamp = " + date.getTime() + "\n\n");
676 // Assert.assertTrue(t1.isTransactionOpen());
677 // Assert.assertFalse(t2.isTransactionOpen());
679 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
680 } catch (PersistenceException e) {
682 if (logger.isDebugEnabled()) {
683 Date date = new java.util.Date();
684 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
685 + "\n SUCCESS! Transaction Wait Timeout worked!" + "\n Caught PersistenceException = " + e
686 + "\n TimeStamp = " + date.getTime() + "\n\n");
688 } catch (Exception e) {
689 // failure due to some other reason
690 if (logger.isDebugEnabled()) {
691 Date date = new java.util.Date();
692 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n Caught Exception = " + e
693 + "\n TimeStamp = " + date.getTime() + "\n\n");
695 logger.error("Exception Occured" + e);
699 if (logger.isDebugEnabled()) {
700 Date date = new java.util.Date();
701 logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");