ECOMP-PAP-REST/src/test/java/org/openecomp/policy/pap/xacml/rest/components/PolicyDBDaoTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ECOMP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017 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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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=========================================================
  19  */
  20
  21 package org.openecomp.policy.pap.xacml.rest.components;
  22
  23 import java.io.ByteArrayInputStream;
  24 import java.io.File;
  25 import java.io.FileOutputStream;
  26 import java.io.IOException;
  27 import java.io.InputStream;
  28 import java.io.OutputStream;
  29 import java.nio.file.Paths;
  30 import java.util.Date;
  31 import java.util.List;
  32
  33 import javax.persistence.EntityManager;
  34 import javax.persistence.EntityManagerFactory;
  35 import javax.persistence.Persistence;
  36 import javax.persistence.PersistenceException;
  37 import javax.persistence.Query;
  38
  39 import org.apache.commons.io.FileUtils;
  40 import org.apache.commons.io.IOUtils;
  41 import org.junit.After;
  42 import org.junit.Assert;
  43 //import org.apache.commons.logging.Log;
  44 //import org.apache.commons.logging.LogFactory;
  45 import org.junit.Before;
  46 import org.junit.Ignore;
  47 import org.junit.Test;
  48 import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
  49 import org.openecomp.policy.common.logging.flexlogger.Logger;
  50 import org.openecomp.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
  51 import org.openecomp.policy.rest.XACMLRestProperties;
  52 import org.openecomp.policy.rest.adapter.PolicyRestAdapter;
  53 import org.openecomp.policy.rest.jpa.ActionBodyEntity;
  54 import org.openecomp.policy.rest.jpa.GroupEntity;
  55 import org.openecomp.policy.rest.jpa.PdpEntity;
  56 import org.openecomp.policy.rest.jpa.PolicyEntity;
  57 import org.openecomp.policy.rest.util.Webapps;
  58 import org.openecomp.policy.xacml.api.pap.EcompPDPGroup;
  59 import org.openecomp.policy.xacml.std.pap.StdPDPGroup;
  60 import org.openecomp.policy.xacml.util.XACMLPolicyWriter;
  61
  62 import com.att.research.xacml.api.pap.PAPException;
  63 import com.att.research.xacml.util.XACMLProperties;
  64
  65 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
  66
  67 @Ignore //only run locally as timing sometimes causes failures on Jenkins
  68 public class PolicyDBDaoTest {
  69
  70         private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
  71
  72         PolicyDBDaoTestClass d;
  73         PolicyDBDao dbd;
  74         PolicyDBDao dbd2;
  75         EntityManagerFactory emf;
  76         @Before
  77         public void init(){
  78                 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME,"xacml.pap.properties");
  79                 emf = Persistence.createEntityManagerFactory("testPapPU");
  80                 EntityManager em = emf.createEntityManager();
  81                 em.getTransaction().begin();
  82                 try{
  83                 em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
  84                 em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
  85                 em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
  86                 em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
  87                 em.createQuery("DELETE FROM PdpEntity").executeUpdate();
  88                 em.createQuery("DELETE FROM GroupEntity").executeUpdate();
  89
  90                 em.getTransaction().commit();
  91                 } catch(Exception e){
  92                         logger.error("Exception Occured"+e);
  93                         em.getTransaction().rollback();
  94                 }
  95                 em.close();
  96                 try {
  97                         dbd = PolicyDBDao.getPolicyDBDaoInstance(emf);
  98                         dbd2 = PolicyDBDao.getPolicyDBDaoInstance(emf);
  99                 } catch (Exception e) {
 100                         //logger.error("Exception Occured"+e);
 101                         Assert.fail();
 102                 }
 103
 104                 d = PolicyDBDao.getPolicyDBDaoTestClass();
 105         }
 106
 107         @After
 108         public void cleanUp(){
 109                 EntityManager em = emf.createEntityManager();
 110                 em.getTransaction().begin();
 111                 try{
 112                 em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
 113                 em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
 114                 em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
 115                 em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
 116                 em.createQuery("DELETE FROM PdpEntity").executeUpdate();
 117                 em.createQuery("DELETE FROM GroupEntity").executeUpdate();
 118
 119                 em.getTransaction().commit();
 120                 } catch(Exception e){
 121                         em.getTransaction().rollback();
 122                 }
 123                 em.close();
 124                 try {
 125                         FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
 126                 } catch (IOException e) {
 127                         //could not delete
 128                 }
 129
 130         }
 131
 132         @Test
 133         public void getScopeAndNameAndTypeTest(){
 134
 135                 String s = d.getGitPath();
 136                 String pathIwantToUse;
 137                 if(s.contains("/")){
 138                         pathIwantToUse = "/root/users/" + s + "/org/openecomp/Config_mypolicy.xml";
 139                 } else {
 140                         pathIwantToUse = "C:\\root\\users\\" + s + "\\org\\openecomp\\Config_mypolicy.xml";
 141                 }
 142                 String[] snt = d.getScopeAndNameAndType(pathIwantToUse);
 143                 Assert.assertEquals("Scope was parsed wrong","org.openecomp", snt[0]);
 144                 Assert.assertEquals("Policy name was parsed wrong","Config_mypolicy.xml", snt[1]);
 145                 Assert.assertEquals("Policy type was parsed wrong","Config", snt[2]);
 146         }
 147         @Test
 148         public void computeScopeTest(){
 149                 Assert.assertEquals("com",d.computeScope("C:\\Users\\testuser\\admin\\repo\\com\\", "C:\\Users\\testuser\\admin\\repo"));
 150                 Assert.assertEquals("org.openecomp.policy",d.computeScope("/Users/testuser/admin/repo/org/openecomp/policy", "/Users/testuser/admin/repo"));
 151         }
 152         @Test
 153         public void getConfigFileTest(){
 154                 PolicyRestAdapter pra = new PolicyRestAdapter();
 155                 pra.setConfigType(ConfigPolicy.JSON_CONFIG);
 156                 String configFile = d.getConfigFile("Config_mypolicy.xml", "org.openecomp", pra);
 157                 Assert.assertEquals("org.openecomp.Config_mypolicy.json", configFile);
 158                 //yes, we can do action files too even though they don't have configs
 159                 configFile = d.getConfigFile("Action_mypolicy.xml", "org.openecomp", pra);
 160                 Assert.assertEquals("org.openecomp.Action_mypolicy.json", configFile);
 161         }
 162
 163         @Test
 164         public void transactionTests(){
 165
 166
 167 //              try{
 168 //                      transac.commitTransaction();
 169 //                      Assert.fail();
 170 //              } catch(IllegalStateException e){
 171 //                      //worked
 172 //              } catch(Exception e2){
 173 //                      Assert.fail();
 174 //              }
 175                 String filePath = null;
 176                 String xmlFile = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<Policy xmlns=\"urn:oasis:names:tc:xacml:3.0:core:schema:wd-17\" PolicyId=\"urn:com:xacml:policy:id:eaa4bb64-59cf-4517-bb44-b2eeabd50b11\" Version=\"1\" RuleCombiningAlgId=\"urn:oasis:names:tc:xacml:3.0:rule-combining-algorithm:permit-overrides\">\n    <Description></Description>\n    <Target>\n        <AnyOf>\n            <AllOf>\n                <Match MatchId=\"org.openecomp.labs.ecomp.function.regex-match\">\n                    <AttributeValue DataType=\"http://www.w3.org/2001/XMLSchema#integer\">99</AttributeValue>\n                    <AttributeDesignator Category=\"urn:oasis:names:tc:xacml:3.0:attribute-category:resource\" AttributeId=\"cpu\" DataType=\"http://www.w3.org/2001/XMLSchema#integer\" MustBePresent=\"false\"/>\n                </Match>\n            </AllOf>\n        </AnyOf>\n    </Target>\n    <Rule RuleId=\"urn:com:xacml:rule:id:3350bf37-43d0-4a94-a317-febec81150d8\" Effect=\"Permit\">\n        <Target/>\n        <ObligationExpressions>\n            <ObligationExpression ObligationId=\"test\" FulfillOn=\"Permit\">\n                <AttributeAssignmentExpression AttributeId=\"performer\" Category=\"urn:oasis:names:tc:xacml:1.0:subject-category:recipient-subject\">\n                    <AttributeValue DataType=\"http://www.w3.org/2001/XMLSchema#string\">PDPAction</AttributeValue>\n                </AttributeAssignmentExpression>\n                <AttributeAssignmentExpression AttributeId=\"type\" Category=\"urn:oasis:names:tc:xacml:3.0:attribute-category:resource\">\n                    <AttributeValue DataType=\"http://www.w3.org/2001/XMLSchema#string\">REST</AttributeValue>\n                </AttributeAssignmentExpression>\n                <AttributeAssignmentExpression AttributeId=\"url\" Category=\"urn:oasis:names:tc:xacml:3.0:attribute-category:resource\">\n                    <AttributeValue DataType=\"http://www.w3.org/2001/XMLSchema#anyURI\">http://localhost:8056/pcd</AttributeValue>\n                </AttributeAssignmentExpression>\n                <AttributeAssignmentExpression AttributeId=\"method\" Category=\"urn:oasis:names:tc:xacml:3.0:attribute-category:resource\">\n                    <AttributeValue DataType=\"http://www.w3.org/2001/XMLSchema#string\">GET</AttributeValue>\n                </AttributeAssignmentExpression>\n                <AttributeAssignmentExpression AttributeId=\"body\" Category=\"urn:oasis:names:tc:xacml:3.0:attribute-category:resource\">\n                    <AttributeValue DataType=\"http://www.w3.org/2001/XMLSchema#anyURI\">$URLaction/com.Action_patbaction7.json</AttributeValue>\n                </AttributeAssignmentExpression>\n            </ObligationExpression>\n        </ObligationExpressions>\n    </Rule>\n</Policy>\n";
 177                 String jsonFile = "{\"actionAttribute\":\"Memory\"}";
 178
 179                 try{
 180                         //policy file
 181                         InputStream in = new ByteArrayInputStream(xmlFile.getBytes());
 182                         String workspaceDir = "src/test/resources/junitTestCreatedDirectory/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WORKSPACE)+"/admin/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_REPOSITORY);
 183                         FileUtils.forceMkdir(new File(workspaceDir+"/com/att"));
 184                         File outFile = new File(workspaceDir+"/org/openecomp/Action_mypol.xml");
 185                         OutputStream out = new FileOutputStream(outFile);
 186                         IOUtils.copy(in, out);
 187                         filePath = outFile.getAbsolutePath();
 188                         out.close();
 189
 190                         //action body file
 191                         InputStream actionIn = new ByteArrayInputStream(jsonFile.getBytes());
 192                         String webappDir = "src/test/resources/junitTestCreatedDirectory/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WORKSPACE);
 193                         XACMLProperties.setProperty(XACMLRestProperties.PROP_PAP_WEBAPPS, webappDir);
 194                         String actionDir = Webapps.getActionHome();
 195                         FileUtils.forceMkdir(new File(actionDir));
 196                         File actionOutFile = new File(actionDir+"/org.openecomp.Action_mypol.json");
 197                         OutputStream actionOut = new FileOutputStream(actionOutFile);
 198                         IOUtils.copy(actionIn, actionOut);
 199                         actionOut.close();
 200
 201                 }catch(Exception e){
 202                         //could not run test
 203                 }
 204                 PolicyDBDaoTransaction transac = dbd.getNewTransaction();
 205                 if(filePath != null){
 206                         try{
 207                                 transac.createPolicy(filePath, "tester");
 208                                 transac.commitTransaction();
 209                         } catch(Exception e){
 210                                 Assert.fail();
 211                         }
 212                         EntityManager getData = emf.createEntityManager();
 213                         Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
 214                         getDataQuery.setParameter("scope", "org.openecomp");
 215                         getDataQuery.setParameter("name","Action_mypol.xml");
 216                         PolicyEntity result = null;
 217                         try{
 218                                 result = (PolicyEntity)getDataQuery.getSingleResult();
 219                         } catch(Exception e){
 220                                 logger.error("Exception Occured"+e);
 221                                 Assert.fail();
 222                         }
 223                         Assert.assertEquals(xmlFile, result.getPolicyData());
 224                         getData.close();
 225                         result = null;
 226                         xmlFile = null;
 227                         try{
 228                                 transac = dbd.getNewTransaction();
 229                                 transac.deletePolicy(filePath);
 230                         } catch(Exception e){
 231                                 logger.error("Exception Occured"+e);
 232                                 Assert.fail();
 233                         }
 234                         Assert.assertTrue(transac.isTransactionOpen());
 235                         try{
 236                                 transac.deletePolicy(filePath);
 237                                 Assert.fail();
 238                         } catch(IllegalStateException e){
 239                                 //pass
 240                         } catch(Exception e){
 241                                 Assert.fail();
 242                         }
 243                         transac.commitTransaction();
 244                         //Assert.assertFalse(transac.isTransactionOpen());
 245                         try{
 246                                 transac = dbd.getNewTransaction();
 247                                 transac.deletePolicy(filePath);
 248                         } catch(Exception e){
 249                                 logger.error("Exception Occured"+e);
 250                                 Assert.fail();
 251                         }
 252                         transac.commitTransaction();
 253                         //Assert.assertFalse(transac.isTransactionOpen());
 254                         String workspaceDir = "src/test/resources/junitTestCreatedDirectory/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WORKSPACE)+"/admin/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_REPOSITORY);
 255                         PolicyDBDaoTransaction willFail = dbd.getNewTransaction();
 256                         File fakeFile = new File("directorythatdoesnotexist/"+workspaceDir);
 257                         try{
 258                         willFail.createPolicy(fakeFile.getAbsolutePath(), "user1");
 259                         Assert.fail();
 260                         } catch(IllegalArgumentException e){
 261                                 if(!e.getMessage().equals("The file path could not be parsed")){
 262                                         Assert.fail();
 263                                 }
 264                         }
 265                         willFail.close();
 266
 267                         fakeFile = new File("directorythatdoesnotexist/"+workspaceDir+"/Action_mypol2.xml");
 268                         willFail = dbd.getNewTransaction();
 269                         try{
 270                         willFail.createPolicy(fakeFile.getAbsolutePath(), "user1");
 271                         Assert.fail();
 272                         } catch(IllegalArgumentException e){
 273                                 if(!e.getMessage().equals("The file path could not be parsed")){
 274                                         Assert.fail();
 275                                 }
 276                         }
 277                         willFail.close();
 278
 279                         fakeFile = new File("directorythatdoesnotexist/"+workspaceDir+"com/att/Action_mypol2.xml");
 280                         willFail = dbd.getNewTransaction();
 281                         try{
 282                         willFail.createPolicy(fakeFile.getAbsolutePath(), "user1");
 283                         Assert.fail();
 284                         } catch(IllegalArgumentException e){
 285                                 if(!e.getMessage().equals("The file path does not exist")){
 286                                         Assert.fail();
 287                                 }
 288                         }
 289                         willFail.close();
 290
 291                         emf = Persistence.createEntityManagerFactory("testPU");
 292                         EntityManager aem = emf.createEntityManager();
 293                         Query actionQuery = aem.createQuery("SELECT a FROM ActionBodyEntity a WHERE a.actionBodyName=:actionBodyName");
 294                         actionQuery.setParameter("actionBodyName", "org.openecomp.Action_mypol.json");
 295                         List<?> actionQueryList = actionQuery.getResultList();
 296                         if(actionQueryList.size() < 1){
 297                                 Assert.fail("ActionBodyEntity not found with actionBodyName=: org.openecomp.Action_mypol.json"  );
 298                         } else if(actionQueryList.size() > 1){
 299                                 //something went wrong
 300                                 Assert.fail("Somehow, more than one ActionBodyEntity with the actionBodyName = org.openecomp.Action_mypol.json");
 301                         } else {
 302                                 ActionBodyEntity abe = (ActionBodyEntity)actionQueryList.get(0);
 303                                 logger.debug("\n\nPolicyDBDaoTest.transactionTests() Assert.assertEquals"
 304                                                 + "\n   abe.getActionBody() = " + abe.getActionBody()
 305                                                 + "\n   jsonFile = " + jsonFile
 306                                                 + "\n\n");
 307                                 Assert.assertEquals(abe.getActionBody(),jsonFile);
 308                         }
 309                 }
 310         }
 311
 312         @Test
 313         public void createFromPolicyObject(){
 314                 String workspaceDir = "src/test/resources/junitTestCreatedDirectory/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WORKSPACE)+"/admin/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_REPOSITORY);
 315                 File parentPath = new File(workspaceDir+"/com/att");
 316                 File scope = new File(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WORKSPACE)+"/admin/"+XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_REPOSITORY));
 317                 Policy policyObject = new ConfigPolicy();
 318                 policyObject.policyAdapter = new PolicyRestAdapter();
 319                 policyObject.policyAdapter.setConfigName("testpolicy1");
 320                 policyObject.policyAdapter.setParentPath(parentPath.getAbsolutePath());
 321                 policyObject.policyAdapter.setUserGitPath(scope.getPath());
 322                 policyObject.policyAdapter.setPolicyDescription("my description");
 323                 policyObject.policyAdapter.setConfigBodyData("this is my test config file");
 324                 policyObject.policyAdapter.setPolicyName("testpolicy1");
 325                 policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
 326                 policyObject.policyAdapter.setPolicyType("Config");
 327                 PolicyType policyTypeObject = new PolicyType();
 328                 policyObject.policyAdapter.setPolicyData(policyTypeObject);
 329                 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
 330                 try{
 331                 transaction.createPolicy(policyObject, "testuser1");
 332                 transaction.commitTransaction();
 333                 } catch(Exception e){
 334                         transaction.rollbackTransaction();
 335                         Assert.fail();
 336                 }
 337
 338                 EntityManager getData = emf.createEntityManager();
 339                 Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
 340                 getDataQuery.setParameter("scope", "org.openecomp");
 341                 getDataQuery.setParameter("name","Config_testpolicy1.xml");
 342                 PolicyEntity result = null;
 343                 try{
 344                 result = (PolicyEntity)getDataQuery.getSingleResult();
 345                 } catch(Exception e){
 346                         logger.error("Exception Occured"+e);
 347                         Assert.fail();
 348                 }
 349                 String expectedData;
 350                 try {
 351                         expectedData = IOUtils.toString(XACMLPolicyWriter.getXmlAsInputStream(policyTypeObject));
 352                 } catch (IOException e1) {
 353                         expectedData = "";
 354                 }
 355                 Assert.assertEquals(expectedData, result.getPolicyData());
 356                 getData.close();
 357                 result = null;
 358                 File policyFile = new File(workspaceDir+"/org/openecomp/Config_testpolicy1.xml");
 359                 try{
 360                         transaction = dbd.getNewTransaction();
 361                         transaction.deletePolicy(policyFile.getAbsolutePath());
 362                 } catch(Exception e){
 363                         logger.error("Exception Occured"+e);
 364                         Assert.fail();
 365                 }
 366                 Assert.assertTrue(transaction.isTransactionOpen());
 367                 try{
 368                         transaction.deletePolicy(policyFile.getAbsolutePath());
 369                         Assert.fail();
 370                 } catch(IllegalStateException e){
 371                         //pass
 372                 } catch(Exception e){
 373                         Assert.fail();
 374                 }
 375                 transaction.commitTransaction();
 376                 Assert.assertFalse(transaction.isTransactionOpen());
 377                 try{
 378                         transaction = dbd.getNewTransaction();
 379                         transaction.deletePolicy(policyFile.getAbsolutePath());
 380                 } catch(Exception e){
 381                         logger.error("Exception Occured"+e);
 382                         Assert.fail();
 383                 }
 384                 //Assert.assertFalse(transaction.isTransactionOpen());
 385                 transaction.commitTransaction();
 386         }
 387
 388         @Test
 389         public void groupTransactions(){
 390                 PolicyDBDaoTransaction group = dbd.getNewTransaction();
 391                 String groupName = "test group 1";
 392                 try{
 393                         group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group","testuser");
 394                         group.commitTransaction();
 395                 } catch(Exception e){
 396                         group.rollbackTransaction();
 397                         logger.error("Exception Occured"+e);
 398                         Assert.fail();
 399                 }
 400                 EntityManager em = emf.createEntityManager();
 401                 Query getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 402                 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 403                 getGroup.setParameter("deleted", false);
 404                 List<?> groups = getGroup.getResultList();
 405                 if(groups.size() != 1){
 406                         Assert.fail();
 407                 }
 408                 GroupEntity groupEntity = (GroupEntity)groups.get(0);
 409                 em.close();
 410                 Assert.assertEquals(groupName, groupEntity.getgroupName());
 411                 Assert.assertEquals("this is a test group", groupEntity.getDescription());
 412                 group = dbd.getNewTransaction();
 413                 try{
 414                         EcompPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName),Paths.get("/"));
 415                         group.deleteGroup(groupToDelete, null,"testuser");
 416                         group.commitTransaction();
 417                 } catch(Exception e){
 418                         group.rollbackTransaction();
 419                         logger.error("Exception Occured"+e);
 420                         Assert.fail();
 421                 }
 422                 em = emf.createEntityManager();
 423                 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 424                 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
 425                 getGroup.setParameter("deleted", false);
 426                 groups = getGroup.getResultList();
 427                 if(groups.size() != 0){
 428                         System.out.println("Group size: "+groups.size());
 429                         Assert.fail();
 430                 }
 431                 em.close();
 432                 //add a pdp to a group
 433                 group = dbd.getNewTransaction();
 434                 try{
 435                         group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
 436                         group.commitTransaction();
 437                 } catch(Exception e){
 438                         group.rollbackTransaction();
 439                         logger.error("Exception Occured"+e);
 440                         Assert.fail();
 441                 }
 442                 group = dbd.getNewTransaction();
 443                 try{
 444                         group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary", "the main pdp", 3232, "testuser");
 445                         group.commitTransaction();
 446                 } catch(Exception e){
 447                         group.rollbackTransaction();
 448                         logger.error("Exception Occured"+e);
 449                         Assert.fail();
 450                 }
 451                 em = emf.createEntityManager();
 452                 Query getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 453                 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 454                 getPdp.setParameter("deleted", false);
 455                 List<?> pdps = getPdp.getResultList();
 456                 if(pdps.size() != 1){
 457                         System.out.println("Group size: "+pdps.size());
 458                         Assert.fail();
 459                 }
 460                 PdpEntity pdp = (PdpEntity)pdps.get(0);
 461                 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
 462                 Assert.assertEquals(pdp.getPdpName(), "primary");
 463                 em.close();
 464                 group = dbd.getNewTransaction();
 465                 try{
 466                         group.removePdpFromGroup("http://localhost:4344/pdp/","testuser");
 467                         group.commitTransaction();
 468                 } catch(Exception e){
 469                         group.rollbackTransaction();
 470                         logger.error("Exception Occured"+e);
 471                         Assert.fail();
 472                 }
 473                 em = emf.createEntityManager();
 474                 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
 475                 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
 476                 getPdp.setParameter("deleted", false);
 477                 pdps = getPdp.getResultList();
 478                 if(pdps.size() != 0){
 479                         System.out.println("Group size: "+pdps.size());
 480                         Assert.fail();
 481                 }
 482                 em.close();
 483
 484                 //add some pdps to groups
 485                 group = dbd.getNewTransaction();
 486                 try{
 487                         group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
 488                         group.commitTransaction();
 489                 } catch(Exception e){
 490                         group.rollbackTransaction();
 491                         logger.error("Exception Occured"+e);
 492                         Assert.fail();
 493                 }
 494                 group = dbd.getNewTransaction();
 495                 try{
 496                         group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
 497                         group.commitTransaction();
 498                 } catch(Exception e){
 499                         group.rollbackTransaction();
 500                         logger.error("Exception Occured"+e);
 501                         Assert.fail();
 502                 }
 503
 504                 group = dbd.getNewTransaction();
 505                 try{
 506                         group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary", "the main pdp", 3232, "testuser");
 507                         group.commitTransaction();
 508                 } catch(Exception e){
 509                         group.rollbackTransaction();
 510                         logger.error("Exception Occured"+e);
 511                         Assert.fail();
 512                 }
 513                 group = dbd.getNewTransaction();
 514                 try{
 515                         group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "secondary", "the second pdp", 3233, "testuser");
 516                         group.commitTransaction();
 517                 } catch(Exception e){
 518                         group.rollbackTransaction();
 519                         logger.error("Exception Occured"+e);
 520                         Assert.fail();
 521                 }
 522                 em = emf.createEntityManager();
 523                 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 524                 getPdp.setParameter("deleted", false);
 525                 pdps = getPdp.getResultList();
 526                 for(Object o : pdps){
 527                         Assert.assertEquals("testgroup1",((PdpEntity)o).getGroup().getgroupName());
 528                 }
 529                 em.close();
 530
 531                 group = dbd.getNewTransaction();
 532                 try{
 533                         EcompPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"),Paths.get("/"));
 534                         EcompPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
 535                         group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
 536                         group.commitTransaction();
 537                 } catch(Exception e){
 538                         group.rollbackTransaction();
 539                         logger.error("Exception Occured"+e);
 540                         Assert.fail();
 541                 }
 542                 em = emf.createEntityManager();
 543                 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 544                 getGroup.setParameter("groupId", "testgroup1");
 545                 getGroup.setParameter("deleted", false);
 546                 groups = getGroup.getResultList();
 547                 if(groups.size() != 0){
 548                         System.out.println("Group size: "+groups.size());
 549                         Assert.fail();
 550                 }
 551                 em.close();
 552
 553                 em = emf.createEntityManager();
 554                 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
 555                 getPdp.setParameter("deleted", false);
 556                 pdps = getPdp.getResultList();
 557                 for(Object o : pdps){
 558                         Assert.assertEquals("testgroup2",((PdpEntity)o).getGroup().getgroupName());
 559                 }
 560                 em.close();
 561
 562                 group = dbd.getNewTransaction();
 563                 try{
 564                         EcompPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
 565                         EcompPDPGroup groupToMoveTo = null;
 566                         group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
 567                         group.commitTransaction();
 568                         Assert.fail();
 569                 } catch(PAPException pe){
 570                         //good, can't delete group with pdps
 571                         group.rollbackTransaction();
 572                 } catch(Exception e){
 573                         group.rollbackTransaction();
 574                         logger.error("Exception Occured"+e);
 575                         Assert.fail();
 576                 }
 577
 578
 579                 //add policy to group
 580
 581                 //update group
 582                 EcompPDPGroup pdpGroup = new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
 583                 group = dbd.getNewTransaction();
 584                 try{
 585                         group.updateGroup(pdpGroup, "testuser");
 586                         group.commitTransaction();
 587                 }catch (Exception e){
 588                         logger.error("Exception Occured"+e);
 589                         group.rollbackTransaction();
 590                         Assert.fail();
 591                 }
 592                 em = emf.createEntityManager();
 593                 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 594                 getGroup.setParameter("groupId", "newtestgroup2");
 595                 getGroup.setParameter("deleted", false);
 596                 groups = getGroup.getResultList();
 597                 if(groups.size() != 1){
 598                         System.out.println("Group size: "+groups.size());
 599                         Assert.fail();
 600                 }
 601                 em.close();
 602                 em = emf.createEntityManager();
 603                 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
 604                 getGroup.setParameter("groupId", "testgroup2");
 605                 getGroup.setParameter("deleted", false);
 606                 groups = getGroup.getResultList();
 607                 if(groups.size() != 0){
 608                         System.out.println("Group size: "+groups.size());
 609                         Assert.fail();
 610                 }
 611                 em.close();
 612                 //update pdp
 613
 614                 //set group as default
 615
 616                 //move pdp to new group
 617
 618
 619         }
 620
 621         @Test
 622         public void encryptionTest(){
 623                 try {
 624                         String encr = d.encryptPassword("testpassword");
 625                         System.out.println("original password: "+"testpassword");
 626                         System.out.println("Encrypted password: "+encr);
 627                         String decr = d.decryptPassword(encr);
 628                         System.out.println("Decrypted password: "+decr);
 629                         Assert.assertEquals("testpassword", decr);
 630                 } catch (Exception e) {
 631                         logger.error("Exception Occured"+e);
 632                         Assert.fail();
 633                 }
 634
 635         }
 636         @Test
 637         public void getDescriptionFromXacmlTest(){
 638                 String myTestDesc = "hello this is a test";
 639                 String desc = d.getDescriptionFromXacml("<Description>"+myTestDesc+"</Description>");
 640                 Assert.assertEquals(myTestDesc, desc);
 641         }
 642
 643         @Test
 644         public void threadingStabilityTest(){
 645                 if(logger.isDebugEnabled()){
 646                         logger.debug("\n\n****************************"
 647                                         + "threadingStabilityTest() entry"
 648                                         + "******************************\n\n");
 649                 }
 650
 651                 PolicyDBDaoTransaction t = dbd.getNewTransaction();
 652                 Assert.assertTrue(t.isTransactionOpen());
 653                 try {
 654                         //Add 1000 ms to the timeout just to be sure it actually times out
 655                         int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 656                         if(logger.isDebugEnabled()){
 657                                 Date date= new java.util.Date();
 658                                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 659                                                 + "\n   sleepTime =  " + sleepTime
 660                                                 + "\n   TimeStamp = " + date.getTime()
 661                                                 + "\n\n");
 662                         }
 663                         Thread.sleep(sleepTime);
 664                 } catch (InterruptedException e) {
 665                         logger.error("Exception Occured"+e);
 666                 }
 667                 if(logger.isDebugEnabled()){
 668                         Date date= new java.util.Date();
 669                         logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 670                                         + "\n   Assert.assertFalse(t.isTransactionOpen() = " + t.isTransactionOpen() + ")"
 671                                         + "\n   TimeStamp = " + date.getTime()
 672                                         + "\n\n");
 673                 }
 674                 Assert.assertFalse(t.isTransactionOpen());
 675
 676
 677                 if(logger.isDebugEnabled()){
 678                         Date date= new java.util.Date();
 679                         logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 680                                         + "\n   a = dbd.getNewTransaction() "
 681                                         + "\n   TimeStamp = " + date.getTime()
 682                                         + "\n\n");
 683                 }
 684                 PolicyDBDaoTransaction a = dbd.getNewTransaction();
 685                 if(logger.isDebugEnabled()){
 686                         Date date= new java.util.Date();
 687                         logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 688                                         + "\n   Assert.assertTrue(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
 689                                         + "\n   TimeStamp = " + date.getTime()
 690                                         + "\n\n");
 691                 }
 692                 Assert.assertTrue(a.isTransactionOpen());
 693
 694                 try {
 695                         //Add 1000 ms to the timeout just to be sure it actually times out
 696                         int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
 697                         if(logger.isDebugEnabled()){
 698                                 Date date= new java.util.Date();
 699                                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 700                                                 + "\n   sleepTime =  " + sleepTime
 701                                                 + "\n   TimeStamp = " + date.getTime()
 702                                                 + "\n\n");
 703                         }
 704                         Thread.sleep(sleepTime);
 705                 } catch (InterruptedException e) {
 706                         logger.error("Exception Occured"+e);
 707                 }
 708                 if(logger.isDebugEnabled()){
 709                         Date date= new java.util.Date();
 710                         logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 711                                         + "\n   b = dbd.getNewTransaction() "
 712                                         + "\n   TimeStamp = " + date.getTime()
 713                                         + "\n\n");
 714                 }
 715                 PolicyDBDaoTransaction b = dbd.getNewTransaction();
 716                 if(logger.isDebugEnabled()){
 717                         Date date= new java.util.Date();
 718                         logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 719                                         + "\n   Assert.assertFalse(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
 720                                         + "\n   TimeStamp = " + date.getTime()
 721                                         + "\n\n");
 722                 }
 723                 Assert.assertFalse(a.isTransactionOpen());
 724                 if(logger.isDebugEnabled()){
 725                         Date date= new java.util.Date();
 726                         logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 727                                         + "\n   Assert.assertTrue(b.isTransactionOpen() = " + b.isTransactionOpen() + ")"
 728                                         + "\n   TimeStamp = " + date.getTime()
 729                                         + "\n\n");
 730                 }
 731                 Assert.assertTrue(b.isTransactionOpen());
 732                 b.close();
 733
 734
 735
 736                 //Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
 737                 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT,"1000");
 738                 //And let's lengthen the transaction timeout to 5000 ms
 739                 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT,"5000");
 740                 //get a transacton
 741                 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
 742                 if(logger.isDebugEnabled()){
 743                         Date date= new java.util.Date();
 744                         logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 745                                         + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 746                                         + "\n   TimeStamp = " + date.getTime()
 747                                         + "\n\n");
 748                 }
 749                 Assert.assertTrue(t1.isTransactionOpen());
 750                 //while it is open, get another from a different DB Dao so it will not collide on the synchronized code segment
 751                 //but will collide at the DB. Remember that the wait time is only 1000 ms
 752                 try {
 753                         //Now the 2nd transaction has a wait timeout in 1000 ms
 754                         PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
 755                         /*
 756                          * Give it plenty of time to time out the second transaction
 757                          * It will actually hang right here until it either gets the lock from the DB or the
 758                          * request for the DB lock times out. The timers are very sloppy so, I have given
 759                          * this plenty of leeway.
 760                          */
 761
 762                         if(logger.isDebugEnabled()){
 763                                 Date date= new java.util.Date();
 764                                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 765                                                 + "\n   Thread.sleep(3000)"
 766                                                 + "\n   TimeStamp = " + date.getTime()
 767                                                 + "\n\n");
 768                         }
 769                         Thread.sleep(3000);
 770                         if(logger.isDebugEnabled()){
 771                                 Date date= new java.util.Date();
 772                                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 773                                                 + "\n   Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
 774                                                 + "\n   Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
 775                                                 + "\n   TimeStamp = " + date.getTime()
 776                                                 + "\n\n");
 777                         }
 778                         //Assert.assertTrue(t1.isTransactionOpen());
 779                         //Assert.assertFalse(t2.isTransactionOpen());
 780
 781                         Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
 782                 } catch (PersistenceException e) {
 783                         //success
 784                         if(logger.isDebugEnabled()){
 785                                 Date date= new java.util.Date();
 786                                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
 787                                                 + "\n   SUCCESS! Transaction Wait Timeout worked!"
 788                                                 + "\n   Caught PersistenceException = " + e
 789                                                 + "\n   TimeStamp = " + date.getTime()
 790                                                 + "\n\n");
 791                         }
 792                 } catch (Exception e) {
 793                         // failure due to some other reason
 794                         if(logger.isDebugEnabled()){
 795                                 Date date= new java.util.Date();
 796                                 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE"
 797                                                 + "\n   Caught Exception = " + e
 798                                                 + "\n   TimeStamp = " + date.getTime()
 799                                                 + "\n\n");
 800                         }
 801                         logger.error("Exception Occured"+e);
 802                         Assert.fail();
 803                 }
 804
 805                 if(logger.isDebugEnabled()){
 806                         Date date= new java.util.Date();
 807                         logger.debug("\n\nthreadingStabilityTest() exit"
 808                                         + "\n   TimeStamp = " + date.getTime()
 809                                         + "\n\n");
 810                 }
 811         }
 812
 813 }