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.Persistence;
34 import javax.persistence.PersistenceException;
35 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
36 import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
37 import org.apache.commons.io.FileUtils;
38 import org.apache.commons.io.IOUtils;
39 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
40 import org.hibernate.Query;
41 import org.hibernate.Session;
42 import org.hibernate.SessionFactory;
43 import org.junit.After;
44 import org.junit.Assert;
45 import org.junit.BeforeClass;
46 import org.junit.Ignore;
47 import org.junit.Test;
48 import org.onap.policy.common.logging.flexlogger.FlexLogger;
49 import org.onap.policy.common.logging.flexlogger.Logger;
50 import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
51 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
52 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
53 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
54 import org.onap.policy.rest.XACMLRestProperties;
55 import org.onap.policy.rest.adapter.PolicyRestAdapter;
56 import org.onap.policy.rest.dao.PolicyDBException;
57 import org.onap.policy.rest.jpa.DatabaseLockEntity;
58 import org.onap.policy.rest.jpa.GroupEntity;
59 import org.onap.policy.rest.jpa.PdpEntity;
60 import org.onap.policy.rest.jpa.PolicyEntity;
61 import org.onap.policy.rest.jpa.UserInfo;
62 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
63 import org.onap.policy.xacml.std.pap.StdEngine;
64 import org.onap.policy.xacml.std.pap.StdPDPGroup;
65 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
67 public class PolicyDBDaoTest {
68 private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
70 static PolicyDBDaoTestClass d;
71 static PolicyDBDao dbd;
72 static PolicyDBDao dbd2;
73 private static Path repository;
74 static StdEngine stdEngine = null;
75 static SessionFactory sessionFactory = null;
78 public static void init() throws PAPException, IOException {
79 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
81 sessionFactory = setupH2DbDaoImpl("testdbdao");
82 dbd = PolicyDBDao.getPolicyDBDaoInstance();
83 dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
84 } catch (Exception e) {
88 d = PolicyDBDao.getPolicyDBDaoTestClass();
89 PolicyDBDao.setJunit(true);
90 repository = Paths.get("src/test/resources/pdps");
91 stdEngine = new StdEngine(repository);
92 dbd.setPapEngine(stdEngine);
96 public void cleanUp() {
98 FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
99 } catch (IOException e) {
104 public static SessionFactory setupH2DbDaoImpl(String dbName) {
107 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
108 BasicDataSource dataSource = new BasicDataSource();
109 dataSource.setDriverClassName("org.h2.Driver");
110 dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
111 dataSource.setUsername("sa");
112 dataSource.setPassword("");
113 LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
114 sessionBuilder.scanPackages("org.onap.*");
116 Properties properties = new Properties();
117 properties.put("hibernate.show_sql", "false");
118 properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
119 properties.put("hibernate.hbm2ddl.auto", "create-drop");
121 sessionBuilder.addProperties(properties);
122 SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
124 new PolicyDBDao(sessionFac);
125 PolicyDbDaoTransactionInstance.setJunit(true);
126 new PolicyDbDaoTransactionInstance(sessionFac);
127 CommonClassDaoImpl.setSessionfactory(sessionFac);
128 new DataToNotifyPdp(new CommonClassDaoImpl());
129 PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
131 DatabaseLockEntity lock = null;
132 Session session = sessionFac.openSession();
133 session.getTransaction().begin();
134 lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
136 lock = new DatabaseLockEntity();
138 session.persist(lock);
141 session.getTransaction().commit();
144 UserInfo user = new UserInfo();
145 user.setUserLoginId("API");
146 user.setUserName("API");
147 Session session2 = sessionFac.openSession();
148 session2.getTransaction().begin();
149 session2.persist(user);
151 session2.getTransaction().commit();
158 private static void setUpAuditDb() {
159 Properties properties = new Properties();
160 properties.put(XACMLRestProperties.PROP_PAP_DB_DRIVER,"org.h2.Driver");
161 properties.put(XACMLRestProperties.PROP_PAP_DB_URL, "jdbc:h2:file:./sql/xacmlTest");
162 properties.put(XACMLRestProperties.PROP_PAP_DB_USER, "sa");
163 properties.put(XACMLRestProperties.PROP_PAP_DB_PASSWORD, "");
165 // create the DB and then close it
166 Persistence.createEntityManagerFactory("testPapPU", properties).close();
170 public void testGetConfigFile() {
171 PolicyRestAdapter pra = new PolicyRestAdapter();
172 pra.setConfigType(ConfigPolicy.JSON_CONFIG);
173 String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
174 Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
175 // yes, we can do action files too even though they don't have configs
176 configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
177 Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
181 public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
182 String policyName = "com.Decision_testname.1.xml";
183 String[] expectedNameAndVersion = new String[2];
184 expectedNameAndVersion[0] = "com.Decision_testname";
185 expectedNameAndVersion[1] = "1";
186 String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
187 Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
191 public void getNameScopeAndVersionFromPdpPolicyTest() {
192 String fileName = "com.Decision_testname.1.xml";
193 String[] expectedArray = new String[3];
194 expectedArray[0] = "Decision_testname.1.xml";
195 expectedArray[2] = "1";
196 expectedArray[1] = "com";
198 String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
199 Assert.assertArrayEquals(expectedArray, returnArray);
203 public void getPdpPolicyNameTest() {
204 String name = "Decision_testname.1.json";
205 String scope = "com";
206 String expectedFinalname = "com.Decision_testname.1.xml";
208 String finalname = d.getPdpPolicyName(name, scope);
209 Assert.assertEquals(expectedFinalname, finalname);
213 public void getPolicySubFileTest() {
214 String name = "Config_testname.1.json";
215 String subFileType = "Config";
216 HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
218 Path path = handle.getPolicySubFile(name, subFileType);
219 Assert.assertNull(path);
223 public void createFromPolicyObject() {
224 Policy policyObject = new ConfigPolicy();
225 policyObject.policyAdapter = new PolicyRestAdapter();
226 policyObject.policyAdapter.setConfigName("testpolicy1");
227 policyObject.policyAdapter.setPolicyDescription("my description");
228 policyObject.policyAdapter.setConfigBodyData("this is my test config file");
229 policyObject.policyAdapter.setPolicyName("SampleTest1206");
230 policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
231 policyObject.policyAdapter.setPolicyType("Config");
232 policyObject.policyAdapter.setDomainDir("com");
233 policyObject.policyAdapter.setVersion("1");
234 policyObject.policyAdapter.setHighestVersion(1);
235 PolicyType policyTypeObject = new PolicyType();
236 policyObject.policyAdapter.setPolicyData(policyTypeObject);
237 ClassLoader classLoader = getClass().getClassLoader();
238 PolicyType policyConfig = new PolicyType();
239 policyConfig.setVersion("1");
240 policyConfig.setPolicyId("");
241 policyConfig.setTarget(new TargetType());
242 policyObject.policyAdapter.setData(policyConfig);
244 policyObject.policyAdapter
245 .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
246 } catch (Exception e2) {
250 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
252 transaction.createPolicy(policyObject, "testuser1");
253 transaction.commitTransaction();
254 } catch (Exception e) {
255 transaction.rollbackTransaction();
259 Session session = sessionFactory.openSession();
260 session.getTransaction().begin();
262 session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
264 policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
265 policyQuery.setParameter("scope", "com");
267 List<?> policyQueryList = policyQuery.list();
268 PolicyEntity result = null;
270 result = (PolicyEntity) policyQueryList.get(0);
271 } catch (Exception e) {
272 logger.error("Exception Occured " + e);
275 session.getTransaction().commit();
280 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
281 } catch (IOException e1) {
284 Assert.assertEquals(expectedData, result.getPolicyData());
287 Assert.assertFalse(transaction.isTransactionOpen());
291 public void groupTransactions() {
292 PolicyDBDaoTransaction group = dbd.getNewTransaction();
293 String groupName = "test group 1";
295 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
297 group.commitTransaction();
298 } catch (Exception e) {
299 group.rollbackTransaction();
300 logger.error("Exception Occured" + e);
303 Session session = sessionFactory.openSession();
304 session.getTransaction().begin();
306 session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
307 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
308 getGroup.setParameter("deleted", false);
309 List<?> groups = getGroup.list();
310 GroupEntity groupEntity = (GroupEntity) groups.get(0);
311 Assert.assertEquals(groupName, groupEntity.getgroupName());
312 Assert.assertEquals("this is a test group", groupEntity.getDescription());
313 session.getTransaction().commit();
316 group = dbd.getNewTransaction();
318 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
319 group.deleteGroup(groupToDelete, null, "testuser");
320 group.commitTransaction();
321 } catch (Exception e) {
322 group.rollbackTransaction();
323 logger.error("Exception Occured" + e);
326 Session session2 = sessionFactory.openSession();
327 session2.getTransaction().begin();
329 session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
330 getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
331 getGroup2.setParameter("deleted", false);
332 List<?> groups2 = getGroup2.list();
333 groups2 = getGroup2.list();
334 if (groups2.size() != 0) {
335 System.out.println("Group size: " + groups2.size());
338 session2.getTransaction().commit();
342 // add a pdp to a group
343 group = dbd.getNewTransaction();
345 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
346 group.commitTransaction();
347 } catch (Exception e) {
348 group.rollbackTransaction();
349 logger.error("Exception Occured" + e);
353 group = dbd.getNewTransaction();
355 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary",
356 "the main pdp", 3232, "testuser");
357 group.commitTransaction();
358 } catch (Exception e) {
359 group.rollbackTransaction();
360 logger.error("Exception Occured" + e);
364 Session session3 = sessionFactory.openSession();
365 session3.getTransaction().begin();
366 Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
367 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
368 getPdp.setParameter("deleted", false);
369 List<?> pdps = getPdp.list();
370 if (pdps.size() != 1) {
371 System.out.println("Group size: " + pdps.size());
374 PdpEntity pdp = (PdpEntity) pdps.get(0);
375 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
376 Assert.assertEquals(pdp.getPdpName(), "primary");
377 session3.getTransaction().commit();
381 group = dbd.getNewTransaction();
383 group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
384 group.commitTransaction();
385 } catch (Exception e) {
386 group.rollbackTransaction();
387 logger.error("Exception Occured" + e);
391 Session session4 = sessionFactory.openSession();
392 session4.getTransaction().begin();
393 Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
394 getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
395 getPdp2.setParameter("deleted", false);
396 List<?> pdps2 = getPdp2.list();
397 if (pdps2.size() != 0) {
398 System.out.println("Group size: " + pdps2.size());
402 session4.getTransaction().commit();
405 // add some pdps to groups
406 group = dbd.getNewTransaction();
408 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
409 group.commitTransaction();
410 } catch (Exception e) {
411 group.rollbackTransaction();
412 logger.error("Exception Occured" + e);
415 group = dbd.getNewTransaction();
417 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
418 group.commitTransaction();
419 } catch (Exception e) {
420 group.rollbackTransaction();
421 logger.error("Exception Occured" + e);
425 group = dbd.getNewTransaction();
427 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
428 "the main pdp", 3232, "testuser");
429 group.commitTransaction();
430 } catch (Exception e) {
431 group.rollbackTransaction();
432 logger.error("Exception Occured" + e);
435 group = dbd.getNewTransaction();
437 group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
438 "secondary", "the second pdp", 3233, "testuser");
439 group.commitTransaction();
440 } catch (Exception e) {
441 group.rollbackTransaction();
442 logger.error("Exception Occured" + e);
446 Session session5 = sessionFactory.openSession();
447 session5.getTransaction().begin();
448 Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
449 getPdp3.setParameter("deleted", false);
450 List<?> pdps3 = getPdp3.list();
451 for (Object obj : pdps3) {
452 Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
455 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();
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());
591 if (logger.isDebugEnabled()) {
592 Date date = new java.util.Date();
593 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n a = dbd.getNewTransaction() "
594 + "\n TimeStamp = " + date.getTime() + "\n\n");
596 PolicyDBDaoTransaction a = dbd.getNewTransaction();
597 if (logger.isDebugEnabled()) {
598 Date date = new java.util.Date();
600 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
601 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
603 Assert.assertTrue(a.isTransactionOpen());
606 // Add 1000 ms to the timeout just to be sure it actually times out
608 Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
609 if (logger.isDebugEnabled()) {
610 Date date = new java.util.Date();
611 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
612 + "\n TimeStamp = " + date.getTime() + "\n\n");
614 Thread.sleep(sleepTime);
615 } catch (InterruptedException e) {
616 logger.error("Exception Occured" + e);
618 if (logger.isDebugEnabled()) {
619 Date date = new java.util.Date();
620 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n b = dbd.getNewTransaction() "
621 + "\n TimeStamp = " + date.getTime() + "\n\n");
623 PolicyDBDaoTransaction b = dbd.getNewTransaction();
624 if (logger.isDebugEnabled()) {
625 Date date = new java.util.Date();
627 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
628 + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
630 Assert.assertFalse(a.isTransactionOpen());
631 if (logger.isDebugEnabled()) {
632 Date date = new java.util.Date();
634 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
635 + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
637 Assert.assertTrue(b.isTransactionOpen());
642 // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
643 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT, "1000");
644 // And let's lengthen the transaction timeout to 5000 ms
645 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
647 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
648 if (logger.isDebugEnabled()) {
649 Date date = new java.util.Date();
651 "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
652 + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
654 Assert.assertTrue(t1.isTransactionOpen());
655 // while it is open, get another from a different DB Dao so it will not collide on the synchronized
657 // but will collide at the DB. Remember that the wait time is only 1000 ms
659 // Now the 2nd transaction has a wait timeout in 1000 ms
660 PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
662 * Give it plenty of time to time out the second transaction It will actually hang right here until
663 * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
664 * sloppy so, I have given this plenty of leeway.
667 if (logger.isDebugEnabled()) {
668 Date date = new java.util.Date();
669 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Thread.sleep(3000)"
670 + "\n TimeStamp = " + date.getTime() + "\n\n");
673 if (logger.isDebugEnabled()) {
674 Date date = new java.util.Date();
675 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
676 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
677 + "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
678 + "\n TimeStamp = " + date.getTime() + "\n\n");
680 // Assert.assertTrue(t1.isTransactionOpen());
681 // Assert.assertFalse(t2.isTransactionOpen());
683 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
684 } catch (PersistenceException e) {
686 if (logger.isDebugEnabled()) {
687 Date date = new java.util.Date();
688 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
689 + "\n SUCCESS! Transaction Wait Timeout worked!" + "\n Caught PersistenceException = " + e
690 + "\n TimeStamp = " + date.getTime() + "\n\n");
692 } catch (Exception e) {
693 // failure due to some other reason
694 if (logger.isDebugEnabled()) {
695 Date date = new java.util.Date();
696 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n Caught Exception = " + e
697 + "\n TimeStamp = " + date.getTime() + "\n\n");
699 logger.error("Exception Occured" + e);
703 if (logger.isDebugEnabled()) {
704 Date date = new java.util.Date();
705 logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");