2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2018 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;
26 import java.io.IOException;
27 import java.nio.file.Path;
28 import java.nio.file.Paths;
29 import java.util.Date;
30 import java.util.List;
32 import javax.persistence.EntityManager;
33 import javax.persistence.EntityManagerFactory;
34 import javax.persistence.Persistence;
35 import javax.persistence.PersistenceException;
36 import javax.persistence.Query;
38 import org.apache.commons.io.FileUtils;
39 import org.apache.commons.io.IOUtils;
40 import org.junit.After;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.Ignore;
44 import org.junit.Test;
45 import org.mockito.Mockito;
46 import org.onap.policy.common.logging.flexlogger.FlexLogger;
47 import org.onap.policy.common.logging.flexlogger.Logger;
48 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
49 import org.onap.policy.rest.XACMLRestProperties;
50 import org.onap.policy.rest.adapter.PolicyRestAdapter;
51 import org.onap.policy.rest.dao.PolicyDBException;
52 import org.onap.policy.rest.jpa.GroupEntity;
53 import org.onap.policy.rest.jpa.PdpEntity;
54 import org.onap.policy.rest.jpa.PolicyEntity;
55 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
56 import org.onap.policy.xacml.std.pap.StdEngine;
57 import org.onap.policy.xacml.std.pap.StdPDPGroup;
58 import org.onap.policy.xacml.util.XACMLPolicyWriter;
60 import com.att.research.xacml.api.pap.PAPException;
61 import com.att.research.xacml.util.XACMLProperties;
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 extends Mockito{
68 private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
70 PolicyDBDaoTestClass d;
73 EntityManagerFactory emf;
74 private Path repository;
75 StdEngine stdEngine = null;
78 public void init() throws PAPException, IOException{
79 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME,"src/test/resources/xacml.pap.properties");
80 emf = Persistence.createEntityManagerFactory("testPapPU");
81 EntityManager em = emf.createEntityManager();
82 em.getTransaction().begin();
84 em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
85 em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
86 em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
87 em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
88 em.createQuery("DELETE FROM PdpEntity").executeUpdate();
89 em.createQuery("DELETE FROM GroupEntity").executeUpdate();
91 em.getTransaction().commit();
93 logger.error("Exception Occured"+e);
94 em.getTransaction().rollback();
98 dbd = PolicyDBDao.getPolicyDBDaoInstance(emf);
99 dbd2 = PolicyDBDao.getPolicyDBDaoInstance(emf);
100 } catch (Exception e) {
104 d = PolicyDBDao.getPolicyDBDaoTestClass();
105 PolicyDBDao.setJunit(true);
106 repository = Paths.get("src/test/resources/pdps");
107 stdEngine = new StdEngine(repository);
108 dbd.setPapEngine(stdEngine);
112 public void cleanUp(){
113 PolicyDBDao.setJunit(false);
114 EntityManager em = emf.createEntityManager();
115 em.getTransaction().begin();
117 em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
118 em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
119 em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
120 em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
121 em.createQuery("DELETE FROM PdpEntity").executeUpdate();
122 em.createQuery("DELETE FROM GroupEntity").executeUpdate();
124 em.getTransaction().commit();
125 } catch(Exception e){
126 em.getTransaction().rollback();
130 FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
131 } catch (IOException e) {
137 public void getConfigFileTest(){
138 PolicyRestAdapter pra = new PolicyRestAdapter();
139 pra.setConfigType(ConfigPolicy.JSON_CONFIG);
140 String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
141 Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
142 //yes, we can do action files too even though they don't have configs
143 configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
144 Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
148 public void createFromPolicyObject(){
149 Policy policyObject = new ConfigPolicy();
150 policyObject.policyAdapter = new PolicyRestAdapter();
151 policyObject.policyAdapter.setConfigName("testpolicy1");
152 policyObject.policyAdapter.setPolicyDescription("my description");
153 policyObject.policyAdapter.setConfigBodyData("this is my test config file");
154 policyObject.policyAdapter.setPolicyName("SampleTest1206");
155 policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
156 policyObject.policyAdapter.setPolicyType("Config");
157 policyObject.policyAdapter.setDomainDir("com");
158 policyObject.policyAdapter.setVersion("1");
159 PolicyType policyTypeObject = new PolicyType();
160 policyObject.policyAdapter.setPolicyData(policyTypeObject);
161 ClassLoader classLoader = getClass().getClassLoader();
162 PolicyType policyConfig = new PolicyType();
163 policyConfig.setVersion(Integer.toString(1));
164 policyConfig.setPolicyId("");
165 policyConfig.setTarget(new TargetType());
166 policyObject.policyAdapter.setData(policyConfig);
167 mock(XACMLPolicyWriter.class);
169 policyObject.policyAdapter.setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
170 } catch (Exception e2) {
174 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
176 transaction.createPolicy(policyObject, "testuser1");
177 transaction.commitTransaction();
178 } catch(Exception e){
179 transaction.rollbackTransaction();
183 EntityManager getData = emf.createEntityManager();
184 Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
185 getDataQuery.setParameter("scope", "com");
186 getDataQuery.setParameter("name","Config_SampleTest1206.1.xml");
187 PolicyEntity result = null;
189 result = (PolicyEntity)getDataQuery.getSingleResult();
190 } catch(Exception e){
191 logger.error("Exception Occured"+e);
196 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
197 } catch (IOException e1) {
200 Assert.assertEquals(expectedData, result.getPolicyData());
204 transaction.commitTransaction();
205 Assert.assertFalse(transaction.isTransactionOpen());
209 public void groupTransactions(){
210 PolicyDBDaoTransaction group = dbd.getNewTransaction();
211 String groupName = "test group 1";
213 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group","testuser");
214 group.commitTransaction();
215 } catch(Exception e){
216 group.rollbackTransaction();
217 logger.error("Exception Occured"+e);
220 EntityManager em = emf.createEntityManager();
221 Query getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
222 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
223 getGroup.setParameter("deleted", false);
224 List<?> groups = getGroup.getResultList();
225 if(groups.size() != 1){
228 GroupEntity groupEntity = (GroupEntity)groups.get(0);
230 Assert.assertEquals(groupName, groupEntity.getgroupName());
231 Assert.assertEquals("this is a test group", groupEntity.getDescription());
232 group = dbd.getNewTransaction();
234 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName),Paths.get("/"));
235 group.deleteGroup(groupToDelete, null,"testuser");
236 group.commitTransaction();
237 } catch(Exception e){
238 group.rollbackTransaction();
239 logger.error("Exception Occured"+e);
242 em = emf.createEntityManager();
243 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
244 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
245 getGroup.setParameter("deleted", false);
246 groups = getGroup.getResultList();
247 if(groups.size() != 0){
248 System.out.println("Group size: "+groups.size());
252 //add a pdp to a group
253 group = dbd.getNewTransaction();
255 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
256 group.commitTransaction();
257 } catch(Exception e){
258 group.rollbackTransaction();
259 logger.error("Exception Occured"+e);
262 group = dbd.getNewTransaction();
264 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary", "the main pdp", 3232, "testuser");
265 group.commitTransaction();
266 } catch(Exception e){
267 group.rollbackTransaction();
268 logger.error("Exception Occured"+e);
271 em = emf.createEntityManager();
272 Query getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
273 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
274 getPdp.setParameter("deleted", false);
275 List<?> pdps = getPdp.getResultList();
276 if(pdps.size() != 1){
277 System.out.println("Group size: "+pdps.size());
280 PdpEntity pdp = (PdpEntity)pdps.get(0);
281 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
282 Assert.assertEquals(pdp.getPdpName(), "primary");
284 group = dbd.getNewTransaction();
286 group.removePdpFromGroup("http://localhost:4344/pdp/","testuser");
287 group.commitTransaction();
288 } catch(Exception e){
289 group.rollbackTransaction();
290 logger.error("Exception Occured"+e);
293 em = emf.createEntityManager();
294 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
295 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
296 getPdp.setParameter("deleted", false);
297 pdps = getPdp.getResultList();
298 if(pdps.size() != 0){
299 System.out.println("Group size: "+pdps.size());
304 //add some pdps to groups
305 group = dbd.getNewTransaction();
307 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
308 group.commitTransaction();
309 } catch(Exception e){
310 group.rollbackTransaction();
311 logger.error("Exception Occured"+e);
314 group = dbd.getNewTransaction();
316 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
317 group.commitTransaction();
318 } catch(Exception e){
319 group.rollbackTransaction();
320 logger.error("Exception Occured"+e);
324 group = dbd.getNewTransaction();
326 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary", "the main pdp", 3232, "testuser");
327 group.commitTransaction();
328 } catch(Exception e){
329 group.rollbackTransaction();
330 logger.error("Exception Occured"+e);
333 group = dbd.getNewTransaction();
335 group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "secondary", "the second pdp", 3233, "testuser");
336 group.commitTransaction();
337 } catch(Exception e){
338 group.rollbackTransaction();
339 logger.error("Exception Occured"+e);
342 em = emf.createEntityManager();
343 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
344 getPdp.setParameter("deleted", false);
345 pdps = getPdp.getResultList();
346 for(Object o : pdps){
347 Assert.assertEquals("testgroup1",((PdpEntity)o).getGroup().getgroupName());
351 group = dbd.getNewTransaction();
353 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"),Paths.get("/"));
354 OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
355 group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
356 group.commitTransaction();
357 } catch(Exception e){
358 group.rollbackTransaction();
359 logger.error("Exception Occured"+e);
362 em = emf.createEntityManager();
363 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
364 getGroup.setParameter("groupId", "testgroup1");
365 getGroup.setParameter("deleted", false);
366 groups = getGroup.getResultList();
367 if(groups.size() != 0){
368 System.out.println("Group size: "+groups.size());
373 em = emf.createEntityManager();
374 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
375 getPdp.setParameter("deleted", false);
376 pdps = getPdp.getResultList();
377 for(Object o : pdps){
378 Assert.assertEquals("testgroup2",((PdpEntity)o).getGroup().getgroupName());
382 group = dbd.getNewTransaction();
384 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
385 OnapPDPGroup groupToMoveTo = null;
386 group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
387 group.commitTransaction();
389 } catch(PolicyDBException pe){
390 //good, can't delete group with pdps
391 group.rollbackTransaction();
392 } catch(Exception e){
393 group.rollbackTransaction();
394 logger.error("Exception Occured"+e);
399 OnapPDPGroup pdpGroup = new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
400 group = dbd.getNewTransaction();
402 group.updateGroup(pdpGroup, "testuser");
403 group.commitTransaction();
404 }catch (Exception e){
405 logger.error("Exception Occured"+e);
406 group.rollbackTransaction();
409 em = emf.createEntityManager();
410 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
411 getGroup.setParameter("groupId", "newtestgroup2");
412 getGroup.setParameter("deleted", false);
413 groups = getGroup.getResultList();
414 if(groups.size() != 1){
415 System.out.println("Group size: "+groups.size());
419 em = emf.createEntityManager();
420 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
421 getGroup.setParameter("groupId", "testgroup2");
422 getGroup.setParameter("deleted", false);
423 groups = getGroup.getResultList();
424 if(groups.size() != 0){
425 System.out.println("Group size: "+groups.size());
433 public void threadingStabilityTest(){
434 if(logger.isDebugEnabled()){
435 logger.debug("\n\n****************************"
436 + "threadingStabilityTest() entry"
437 + "******************************\n\n");
440 PolicyDBDaoTransaction t = dbd.getNewTransaction();
441 Assert.assertTrue(t.isTransactionOpen());
443 //Add 1000 ms to the timeout just to be sure it actually times out
444 int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
445 if(logger.isDebugEnabled()){
446 Date date= new java.util.Date();
447 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
448 + "\n sleepTime = " + sleepTime
449 + "\n TimeStamp = " + date.getTime()
452 Thread.sleep(sleepTime);
453 } catch (InterruptedException e) {
454 logger.error("Exception Occured"+e);
456 if(logger.isDebugEnabled()){
457 Date date= new java.util.Date();
458 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
459 + "\n Assert.assertFalse(t.isTransactionOpen() = " + t.isTransactionOpen() + ")"
460 + "\n TimeStamp = " + date.getTime()
463 Assert.assertFalse(t.isTransactionOpen());
466 if(logger.isDebugEnabled()){
467 Date date= new java.util.Date();
468 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
469 + "\n a = dbd.getNewTransaction() "
470 + "\n TimeStamp = " + date.getTime()
473 PolicyDBDaoTransaction a = dbd.getNewTransaction();
474 if(logger.isDebugEnabled()){
475 Date date= new java.util.Date();
476 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
477 + "\n Assert.assertTrue(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
478 + "\n TimeStamp = " + date.getTime()
481 Assert.assertTrue(a.isTransactionOpen());
484 //Add 1000 ms to the timeout just to be sure it actually times out
485 int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
486 if(logger.isDebugEnabled()){
487 Date date= new java.util.Date();
488 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
489 + "\n sleepTime = " + sleepTime
490 + "\n TimeStamp = " + date.getTime()
493 Thread.sleep(sleepTime);
494 } catch (InterruptedException e) {
495 logger.error("Exception Occured"+e);
497 if(logger.isDebugEnabled()){
498 Date date= new java.util.Date();
499 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
500 + "\n b = dbd.getNewTransaction() "
501 + "\n TimeStamp = " + date.getTime()
504 PolicyDBDaoTransaction b = dbd.getNewTransaction();
505 if(logger.isDebugEnabled()){
506 Date date= new java.util.Date();
507 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
508 + "\n Assert.assertFalse(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
509 + "\n TimeStamp = " + date.getTime()
512 Assert.assertFalse(a.isTransactionOpen());
513 if(logger.isDebugEnabled()){
514 Date date= new java.util.Date();
515 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
516 + "\n Assert.assertTrue(b.isTransactionOpen() = " + b.isTransactionOpen() + ")"
517 + "\n TimeStamp = " + date.getTime()
520 Assert.assertTrue(b.isTransactionOpen());
525 //Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
526 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT,"1000");
527 //And let's lengthen the transaction timeout to 5000 ms
528 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT,"5000");
530 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
531 if(logger.isDebugEnabled()){
532 Date date= new java.util.Date();
533 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
534 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
535 + "\n TimeStamp = " + date.getTime()
538 Assert.assertTrue(t1.isTransactionOpen());
539 //while it is open, get another from a different DB Dao so it will not collide on the synchronized code segment
540 //but will collide at the DB. Remember that the wait time is only 1000 ms
542 //Now the 2nd transaction has a wait timeout in 1000 ms
543 PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
545 * Give it plenty of time to time out the second transaction
546 * It will actually hang right here until it either gets the lock from the DB or the
547 * request for the DB lock times out. The timers are very sloppy so, I have given
548 * this plenty of leeway.
551 if(logger.isDebugEnabled()){
552 Date date= new java.util.Date();
553 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
554 + "\n Thread.sleep(3000)"
555 + "\n TimeStamp = " + date.getTime()
559 if(logger.isDebugEnabled()){
560 Date date= new java.util.Date();
561 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
562 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
563 + "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
564 + "\n TimeStamp = " + date.getTime()
567 //Assert.assertTrue(t1.isTransactionOpen());
568 //Assert.assertFalse(t2.isTransactionOpen());
570 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
571 } catch (PersistenceException e) {
573 if(logger.isDebugEnabled()){
574 Date date= new java.util.Date();
575 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
576 + "\n SUCCESS! Transaction Wait Timeout worked!"
577 + "\n Caught PersistenceException = " + e
578 + "\n TimeStamp = " + date.getTime()
581 } catch (Exception e) {
582 // failure due to some other reason
583 if(logger.isDebugEnabled()){
584 Date date= new java.util.Date();
585 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE"
586 + "\n Caught Exception = " + e
587 + "\n TimeStamp = " + date.getTime()
590 logger.error("Exception Occured"+e);
594 if(logger.isDebugEnabled()){
595 Date date= new java.util.Date();
596 logger.debug("\n\nthreadingStabilityTest() exit"
597 + "\n TimeStamp = " + date.getTime()