+ @BeforeClass
+ public static void init() throws PAPException, IOException {
+ System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
+ try {
+ sessionFactory = setupH2DbDaoImpl("testdbdao");
+ dbd = PolicyDbDao.getPolicyDbDaoInstance();
+ dbd2 = PolicyDbDao.getPolicyDbDaoInstance();
+ } catch (Exception e) {
+ Assert.fail();
+ }
+
+ d = PolicyDbDao.getPolicyDbDaoTestClass();
+ PolicyDbDao.setJunit(true);
+ repository = Paths.get("src/test/resources/pdps");
+ stdEngine = new StdEngine(repository);
+ dbd.setPapEngine(stdEngine);
+ }
+
+ @After
+ public void cleanUp() {
+ try {
+ FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
+ } catch (IOException e) {
+ // could not delete
+ }
+ }
+
+ public static SessionFactory setupH2DbDaoImpl(String dbName) {
+ setUpAuditDb();
+
+ System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
+ BasicDataSource dataSource = new BasicDataSource();
+ dataSource.setDriverClassName("org.h2.Driver");
+ dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
+ dataSource.setUsername("sa");
+ dataSource.setPassword("");
+ LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
+ sessionBuilder.scanPackages("org.onap.*");
+
+ Properties properties = new Properties();
+ properties.put("hibernate.show_sql", "false");
+ properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
+ properties.put("hibernate.hbm2ddl.auto", "create-drop");
+
+ sessionBuilder.addProperties(properties);
+ SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
+
+ new PolicyDbDao(sessionFac);
+ PolicyDbDaoTransactionInstance.setJunit(true);
+ new PolicyDbDaoTransactionInstance(sessionFac);
+ CommonClassDaoImpl.setSessionfactory(sessionFac);
+ new DataToNotifyPdp(new CommonClassDaoImpl());
+ PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
+
+ DatabaseLockEntity lock = null;
+ Session session = sessionFac.openSession();
+ session.getTransaction().begin();
+ lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
+ if (lock == null) {
+ lock = new DatabaseLockEntity();
+ lock.setKey(1);
+ session.persist(lock);
+ session.flush();
+ }
+ session.getTransaction().commit();
+ session.close();
+
+ UserInfo user = new UserInfo();
+ user.setUserLoginId("API");
+ user.setUserName("API");
+ Session session2 = sessionFac.openSession();
+ session2.getTransaction().begin();
+ session2.persist(user);
+
+ session2.getTransaction().commit();
+ session2.close();
+
+ return sessionFac;
+ }
+
+ private static void setUpAuditDb() {
+ Properties properties = new Properties();
+ properties.put(XacmlRestProperties.PROP_PAP_DB_DRIVER, "org.h2.Driver");
+ properties.put(XacmlRestProperties.PROP_PAP_DB_URL, "jdbc:h2:file:./sql/xacmlTest");
+ properties.put(XacmlRestProperties.PROP_PAP_DB_USER, "sa");
+ properties.put(XacmlRestProperties.PROP_PAP_DB_PASSWORD, "");
+
+ // create the DB and then close it
+ Persistence.createEntityManagerFactory("testPapPU", properties).close();
+ }
+
+ @Test
+ public void testGetConfigFile() {
+ PolicyRestAdapter pra = new PolicyRestAdapter();
+ pra.setConfigType(ConfigPolicy.JSON_CONFIG);
+ String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
+ Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
+ // yes, we can do action files too even though they don't have configs
+ configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
+ Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
+ }
+
+ @Test
+ public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDbException {
+ String policyName = "com.Decision_testname.1.xml";
+ String[] expectedNameAndVersion = new String[2];
+ expectedNameAndVersion[0] = "com.Decision_testname";
+ expectedNameAndVersion[1] = "1";
+ String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
+ Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
+ }
+
+ @Test
+ public void getNameScopeAndVersionFromPdpPolicyTest() {
+ String fileName = "com.Decision_testname.1.xml";
+ String[] expectedArray = new String[3];
+ expectedArray[0] = "Decision_testname.1.xml";
+ expectedArray[2] = "1";
+ expectedArray[1] = "com";
+
+ String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
+ Assert.assertArrayEquals(expectedArray, returnArray);
+ }
+
+ @Test
+ public void getPdpPolicyNameTest() {
+ String name = "Decision_testname.1.json";
+ String scope = "com";
+ String expectedFinalname = "com.Decision_testname.1.xml";
+
+ String finalname = d.getPdpPolicyName(name, scope);
+ Assert.assertEquals(expectedFinalname, finalname);
+ }
+
+ @Test
+ public void getPolicySubFileTest() {
+ String name = "Config_testname.1.json";
+ String subFileType = "Config";
+ HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
+
+ Path path = handle.getPolicySubFile(name, subFileType);
+ Assert.assertNull(path);
+ }
+
+ @Test
+ public void createFromPolicyObject() {
+ Policy policyObject = new ConfigPolicy();
+ policyObject.policyAdapter = new PolicyRestAdapter();
+ policyObject.policyAdapter.setConfigName("testpolicy1");
+ policyObject.policyAdapter.setPolicyDescription("my description");
+ policyObject.policyAdapter.setConfigBodyData("this is my test config file");
+ policyObject.policyAdapter.setPolicyName("SampleTest1206");
+ policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
+ policyObject.policyAdapter.setPolicyType("Config");
+ policyObject.policyAdapter.setDomainDir("com");
+ policyObject.policyAdapter.setVersion("1");
+ policyObject.policyAdapter.setHighestVersion(1);
+ PolicyType policyTypeObject = new PolicyType();
+ policyObject.policyAdapter.setPolicyData(policyTypeObject);
+ ClassLoader classLoader = getClass().getClassLoader();
+ PolicyType policyConfig = new PolicyType();
+ policyConfig.setVersion("1");
+ policyConfig.setPolicyId("");
+ policyConfig.setTarget(new TargetType());
+ policyObject.policyAdapter.setData(policyConfig);
+ try {
+ policyObject.policyAdapter
+ .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
+ } catch (Exception e2) {
+ fail();
+ }
+
+ PolicyDbDaoTransaction transaction = dbd.getNewTransaction();
+ try {
+ transaction.createPolicy(policyObject, "testuser1");
+ transaction.commitTransaction();
+ } catch (Exception e) {
+ transaction.rollbackTransaction();
+ Assert.fail();
+ }
+
+ Session session = sessionFactory.openSession();
+ session.getTransaction().begin();
+ Query policyQuery =
+ session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
+
+ policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
+ policyQuery.setParameter("scope", "com");
+
+ List<?> policyQueryList = policyQuery.list();
+ PolicyEntity result = null;
+ try {
+ result = (PolicyEntity) policyQueryList.get(0);
+ } catch (Exception e) {
+ logger.error("Exception Occured " + e);
+ Assert.fail();
+ }
+ session.getTransaction().commit();
+ session.close();
+
+ String expectedData;
+ try {
+ expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
+ } catch (IOException e1) {
+ expectedData = "";
+ }
+ Assert.assertEquals(expectedData, result.getPolicyData());
+ result = null;
+
+ Assert.assertFalse(transaction.isTransactionOpen());
+ }
+
+ @Test
+ public void groupTransactions() {
+ PolicyDbDaoTransaction group = dbd.getNewTransaction();
+ String groupName = "test group 1";
+ try {
+ group.createGroup(PolicyDbDao.createNewPdpGroupId(groupName), groupName, "this is a test group",
+ "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+ Session session = sessionFactory.openSession();
+ session.getTransaction().begin();
+ Query getGroup =
+ session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup.setParameter("groupId", PolicyDbDao.createNewPdpGroupId(groupName));
+ getGroup.setParameter("deleted", false);
+ List<?> groups = getGroup.list();
+ GroupEntity groupEntity = (GroupEntity) groups.get(0);
+ Assert.assertEquals(groupName, groupEntity.getGroupName());
+ Assert.assertEquals("this is a test group", groupEntity.getDescription());
+ session.getTransaction().commit();
+ session.close();
+
+ group = dbd.getNewTransaction();
+ try {
+ OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDbDao.createNewPdpGroupId(groupName), Paths.get("/"));
+ group.deleteGroup(groupToDelete, null, "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+ Session session2 = sessionFactory.openSession();
+ session2.getTransaction().begin();
+ Query getGroup2 =
+ session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup2.setParameter("groupId", PolicyDbDao.createNewPdpGroupId(groupName));
+ getGroup2.setParameter("deleted", false);
+ List<?> groups2 = getGroup2.list();
+ groups2 = getGroup2.list();
+ if (groups2.size() != 0) {
+ System.out.println("Group size: " + groups2.size());
+ Assert.fail();
+ }
+ session2.getTransaction().commit();
+ session2.close();
+
+ // add a pdp to a group
+ group = dbd.getNewTransaction();
+ try {
+ group.createGroup(PolicyDbDao.createNewPdpGroupId(groupName), groupName, "test group", "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+
+ group = dbd.getNewTransaction();
+ try {
+ group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDbDao.createNewPdpGroupId(groupName), "primary",
+ "the main pdp", 3232, "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+
+ Session session3 = sessionFactory.openSession();
+ session3.getTransaction().begin();
+ Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
+ getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
+ getPdp.setParameter("deleted", false);
+ List<?> pdps = getPdp.list();
+ if (pdps.size() != 1) {
+ System.out.println("Group size: " + pdps.size());
+ Assert.fail();
+ }
+ PdpEntity pdp = (PdpEntity) pdps.get(0);
+ Assert.assertEquals(groupName, pdp.getGroup().getGroupName());
+ Assert.assertEquals(pdp.getPdpName(), "primary");
+ session3.getTransaction().commit();
+ session3.close();
+
+ group = dbd.getNewTransaction();
+ try {
+ group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+
+ Session session4 = sessionFactory.openSession();
+ session4.getTransaction().begin();
+ Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
+ getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
+ getPdp2.setParameter("deleted", false);
+ List<?> pdps2 = getPdp2.list();
+ if (pdps2.size() != 0) {
+ System.out.println("Group size: " + pdps2.size());
+ Assert.fail();
+ }
+
+ session4.getTransaction().commit();
+ session4.close();
+
+ // add some pdps to groups
+ group = dbd.getNewTransaction();
+ try {
+ group.createGroup(PolicyDbDao.createNewPdpGroupId("testgroup1"), "testgroup1", "test group", "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+ group = dbd.getNewTransaction();
+ try {
+ group.createGroup(PolicyDbDao.createNewPdpGroupId("testgroup2"), "testgroup2", "test group", "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+
+ group = dbd.getNewTransaction();
+ try {
+ group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDbDao.createNewPdpGroupId("testgroup1"), "primary",
+ "the main pdp", 3232, "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+ group = dbd.getNewTransaction();
+ try {
+ group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDbDao.createNewPdpGroupId("testgroup1"),
+ "secondary", "the second pdp", 3233, "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+
+ Session session5 = sessionFactory.openSession();
+ session5.getTransaction().begin();
+ Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
+ getPdp3.setParameter("deleted", false);
+ List<?> pdps3 = getPdp3.list();
+ for (Object obj : pdps3) {
+ Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getGroupName());
+ }
+
+ session5.getTransaction().commit();
+ session5.close();
+
+ group = dbd.getNewTransaction();
+ try {
+ OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDbDao.createNewPdpGroupId("testgroup1"), Paths.get("/"));
+ OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDbDao.createNewPdpGroupId("testgroup2"), Paths.get("/"));
+ group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+
+ Session session6 = sessionFactory.openSession();
+ session6.getTransaction().begin();
+ Query getGroup3 =
+ session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup3.setParameter("groupId", "testgroup1");
+ getGroup3.setParameter("deleted", false);
+ List<?> groups3 = getGroup3.list();
+ if (groups3.size() != 0) {
+ System.out.println("Group size: " + groups3.size());
+ Assert.fail();
+ }
+
+ session6.getTransaction().commit();
+ session6.close();
+
+ Session session7 = sessionFactory.openSession();
+ session7.getTransaction().begin();
+ Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
+ getPdp4.setParameter("deleted", false);
+ List<?> pdps4 = getPdp4.list();
+ for (Object obj : pdps4) {
+ Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getGroupName());
+ }
+
+ session7.getTransaction().commit();
+ session7.close();
+
+ group = dbd.getNewTransaction();
+ try {
+ OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDbDao.createNewPdpGroupId("testgroup2"), Paths.get("/"));
+ OnapPDPGroup groupToMoveTo = null;
+ group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
+ group.commitTransaction();
+ Assert.fail();
+ } catch (PolicyDbException pe) {
+ // good, can't delete group with pdps
+ group.rollbackTransaction();
+ } catch (Exception e) {
+ group.rollbackTransaction();
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }
+
+ // update group
+ OnapPDPGroup pdpGroup =
+ new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
+ group = dbd.getNewTransaction();
+ try {
+ group.updateGroup(pdpGroup, "testuser", "testuser");
+ group.commitTransaction();
+ } catch (Exception e) {
+ logger.error("Exception Occured" + e);
+ group.rollbackTransaction();
+ Assert.fail();
+ }
+
+ Session session8 = sessionFactory.openSession();
+ session8.getTransaction().begin();
+ Query getGroup4 =
+ session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup4.setParameter("groupId", "newtestgroup2");
+ getGroup4.setParameter("deleted", false);
+ List<?> groups4 = getGroup4.list();
+ if (groups4.size() != 1) {
+ System.out.println("Group size: " + groups4.size());
+ Assert.fail();
+ }
+
+ session8.getTransaction().commit();
+ session8.close();
+
+ Session session9 = sessionFactory.openSession();
+ session9.getTransaction().begin();
+ Query getGroup5 =
+ session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup5.setParameter("groupId", "testgroup2");
+ getGroup5.setParameter("deleted", false);
+ List<?> groups5 = getGroup5.list();
+ if (groups5.size() != 0) {
+ System.out.println("Group size: " + groups5.size());
+ Assert.fail();
+ }
+
+ session9.getTransaction().commit();
+ session9.close();
+ }
+
+ @Ignore
+ @Test
+ public void threadingStabilityTest() {
+ if (logger.isDebugEnabled()) {
+ logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
+ + "******************************\n\n");
+ }
+
+ PolicyDbDaoTransaction t = dbd.getNewTransaction();
+ Assert.assertTrue(t.isTransactionOpen());
+ try {
+ // Add 1000 ms to the timeout just to be sure it actually times out
+ int sleepTime =
+ Integer.parseInt(XACMLProperties.getProperty(XacmlRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Thread.sleep(sleepTime);
+ } catch (InterruptedException e) {
+ logger.error("Exception Occured" + e);
+ }
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(t.isTransactionOpen() = "
+ + t.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Assert.assertFalse(t.isTransactionOpen());
+
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n a = dbd.getNewTransaction() "
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ PolicyDbDaoTransaction a = dbd.getNewTransaction();
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
+ + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Assert.assertTrue(a.isTransactionOpen());
+
+ try {
+ // Add 1000 ms to the timeout just to be sure it actually times out
+ int sleepTime =
+ Integer.parseInt(XACMLProperties.getProperty(XacmlRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Thread.sleep(sleepTime);
+ } catch (InterruptedException e) {
+ logger.error("Exception Occured" + e);
+ }
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n b = dbd.getNewTransaction() "
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ PolicyDbDaoTransaction b = dbd.getNewTransaction();
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
+ + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Assert.assertFalse(a.isTransactionOpen());
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
+ + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Assert.assertTrue(b.isTransactionOpen());
+ b.close();
+
+ // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
+ System.setProperty(XacmlRestProperties.PROP_PAP_TRANS_WAIT, "1000");
+ // And let's lengthen the transaction timeout to 5000 ms
+ System.setProperty(XacmlRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
+ // get a transacton
+ PolicyDbDaoTransaction t1 = dbd.getNewTransaction();
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
+ + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Assert.assertTrue(t1.isTransactionOpen());
+ // while it is open, get another from a different DB Dao so it will not collide on the synchronized
+ // code segment
+ // but will collide at the DB. Remember that the wait time is only 1000 ms
+ try {
+ // Now the 2nd transaction has a wait timeout in 1000 ms
+ PolicyDbDaoTransaction t2 = dbd2.getNewTransaction();
+ /*
+ * Give it plenty of time to time out the second transaction It will actually hang right here until
+ * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
+ * sloppy so, I have given this plenty of leeway.
+ */
+
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Thread.sleep(3000)"
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ Thread.sleep(3000);
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
+ + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
+ + "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ // Assert.assertTrue(t1.isTransactionOpen());
+ // Assert.assertFalse(t2.isTransactionOpen());
+
+ Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
+ } catch (PersistenceException e) {
+ // success
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
+ + "\n SUCCESS! Transaction Wait Timeout worked!" + "\n Caught PersistenceException = " + e
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ } catch (Exception e) {
+ // failure due to some other reason
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n Caught Exception = " + e
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ logger.error("Exception Occured" + e);
+ Assert.fail();
+ }