POLICY-SDK-APP/src/test/java/org/onap/policy/admin/PolicyManagerServletTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Engine
   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 package org.onap.policy.admin;
  21
  22 import static org.junit.Assert.fail;
  23
  24 import java.io.BufferedReader;
  25 import java.io.File;
  26 import java.io.StringReader;
  27 import java.util.ArrayList;
  28 import java.util.Collections;
  29 import java.util.List;
  30
  31 import javax.servlet.ServletConfig;
  32 import javax.servlet.http.HttpServletRequest;
  33 import javax.servlet.http.HttpServletResponse;
  34
  35 import org.apache.commons.io.IOUtils;
  36 import org.junit.Before;
  37 import org.junit.Test;
  38 import org.mockito.Mockito;
  39 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  40 import org.onap.policy.common.logging.flexlogger.Logger;
  41 import org.onap.policy.controller.CreateDcaeMicroServiceController;
  42 import org.onap.policy.controller.PolicyController;
  43 import org.onap.policy.rest.dao.CommonClassDao;
  44 import org.onap.policy.rest.jpa.ActionBodyEntity;
  45 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
  46 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  47 import org.onap.policy.rest.jpa.PolicyEditorScopes;
  48 import org.onap.policy.rest.jpa.PolicyEntity;
  49 import org.onap.policy.rest.jpa.PolicyVersion;
  50 import org.onap.policy.rest.jpa.UserInfo;
  51 import org.openecomp.policy.model.Roles;
  52
  53 public class PolicyManagerServletTest extends Mockito{
  54
  55         private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
  56         private List<String> headers = new ArrayList<String>();
  57
  58         private static List<Object> rolesdata;
  59         private static List<Object> basePolicyData;
  60         private static List<Object> policyEditorScopes;
  61         private static List<Object> policyVersion;
  62         private static CommonClassDao commonClassDao;
  63
  64         @Before
  65         public void setUp() throws Exception{
  66                 logger.info("setUp: Entering");
  67                 PolicyController.setjUnit(true);
  68                 UserInfo userinfo = new UserInfo();
  69                 userinfo.setUserLoginId("Test");
  70                 userinfo.setUserName("Test");
  71                 //Roles Data
  72         rolesdata = new ArrayList<>();
  73         Roles roles = new Roles();
  74         roles.setLoginId("Test");
  75         roles.setRole("super-admin");
  76         Roles roles1 = new Roles();
  77         roles1.setLoginId("Test");
  78         roles1.setRole("admin");
  79         roles1.setScope("['com','Test']");
  80         rolesdata.add(roles);
  81         rolesdata.add(roles1);
  82
  83         //PolicyEntity Data
  84         basePolicyData = new ArrayList<>();
  85         String policyContent = "";
  86         try {
  87                         ClassLoader classLoader = getClass().getClassLoader();
  88                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
  89                 } catch (Exception e1) {
  90                         logger.error("Exception Occured"+e1);
  91                 }
  92         PolicyEntity entity = new PolicyEntity();
  93         entity.setPolicyName("Config_SampleTest.1.xml");
  94         entity.setPolicyData(policyContent);
  95         entity.setScope("com");
  96         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
  97         configurationEntity.setConfigBody("Sample Test");
  98         configurationEntity.setConfigType("OTHER");
  99         configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
 100         configurationEntity.setDescription("test");
 101         entity.setConfigurationData(configurationEntity);
 102         basePolicyData.add(entity);
 103
 104         //PolicyEditorScopes data
 105         policyEditorScopes = new ArrayList<>();
 106         PolicyEditorScopes scopes = new PolicyEditorScopes();
 107         scopes.setScopeName("com");
 108         scopes.setUserCreatedBy(userinfo);
 109         scopes.setUserModifiedBy(userinfo);
 110         PolicyEditorScopes scopes1 = new PolicyEditorScopes();
 111         scopes1.setScopeName("com\\Test");
 112         scopes1.setUserCreatedBy(userinfo);
 113         scopes1.setUserModifiedBy(userinfo);
 114         policyEditorScopes.add(scopes);
 115         policyEditorScopes.add(scopes1);
 116
 117         //PolicyVersion data
 118         policyVersion = new ArrayList<>();
 119         PolicyVersion policy = new PolicyVersion();
 120         policy.setPolicyName("com\\Config_SampleTest1206");
 121         policy.setActiveVersion(1);
 122         policy.setHigherVersion(1);
 123         policy.setCreatedBy("Test");
 124         policy.setModifiedBy("Test");
 125         policyVersion.add(policy);
 126         }
 127
 128         @Test
 129         public void testInit(){
 130                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 131                 ServletConfig servletConfig = mock(ServletConfig.class);
 132         try {
 133                 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 134                 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 135                 System.setProperty("xacml.rest.admin.closedLoopJSON", new File(".").getCanonicalPath() + File.separator + "src"+ File.separator + "test" + File.separator + "resources" + File.separator + "JSONConfig.json");
 136                         servlet.init(servletConfig);
 137                 } catch (Exception e1) {
 138                         logger.error("Exception Occured"+e1);
 139                         fail();
 140                 }
 141         }
 142
 143         @SuppressWarnings("static-access")
 144         @Test
 145         public void testDescribePolicy(){
 146                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 147                 HttpServletRequest request = mock(HttpServletRequest.class);
 148         HttpServletResponse response = mock(HttpServletResponse.class);
 149         PolicyController controller = mock(PolicyController.class);
 150         BufferedReader reader = new BufferedReader(new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
 151         try {
 152                         when(request.getReader()).thenReturn(reader);
 153                         String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
 154                         when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
 155                         servlet.setPolicyController(controller);
 156                         servlet.doPost(request, response);
 157                 } catch (Exception e1) {
 158                         logger.error("Exception Occured"+e1);
 159                         fail();
 160                 }
 161         }
 162
 163
 164         @SuppressWarnings("static-access")
 165         @Test
 166         public void testPolicyScopeList(){
 167                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 168                 HttpServletRequest request = mock(HttpServletRequest.class);
 169         HttpServletResponse response = mock(HttpServletResponse.class);
 170         PolicyController controller = mock(PolicyController.class);
 171         List<String> list = new ArrayList<>();
 172         list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
 173         list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
 174         for(int i =0; i < list.size(); i++){
 175                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 176             try {
 177                         when(request.getReader()).thenReturn(reader);
 178                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 179                         when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
 180                         when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null)).thenReturn(policyEditorScopes);
 181                         when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null)).thenReturn(policyVersion);
 182                         servlet.setPolicyController(controller);
 183                         servlet.setTestUserId("Test");
 184                         servlet.doPost(request, response);
 185                 } catch (Exception e1) {
 186                         logger.error("Exception Occured"+e1);
 187                         fail();
 188                 }
 189         }
 190         }
 191
 192         @SuppressWarnings("static-access")
 193         @Test
 194         public void editBasePolicyTest(){
 195                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 196                 HttpServletRequest request = mock(HttpServletRequest.class);
 197         HttpServletResponse response = mock(HttpServletResponse.class);
 198         PolicyController controller = mock(PolicyController.class);
 199         List<String> list = new ArrayList<>();
 200         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
 201         for(int i =0; i < list.size(); i++){
 202                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 203             try {
 204                         when(request.getReader()).thenReturn(reader);
 205                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 206                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(basePolicyData);
 207                         servlet.setPolicyController(controller);
 208                         servlet.setTestUserId("Test");
 209                         servlet.doPost(request, response);
 210                 } catch (Exception e1) {
 211                         logger.error("Exception Occured"+e1);
 212                         fail();
 213                 }
 214         }
 215         }
 216
 217         @SuppressWarnings("static-access")
 218         @Test
 219         public void editBRMSParamPolicyTest(){
 220                 List<Object> policyData = new ArrayList<>();
 221         String policyContent = "";
 222         String configData = "";
 223         try {
 224                         ClassLoader classLoader = getClass().getClassLoader();
 225                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 226                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
 227                 } catch (Exception e1) {
 228                         logger.error("Exception Occured"+e1);
 229                 }
 230         PolicyEntity entity = new PolicyEntity();
 231         entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 232         entity.setPolicyData(policyContent);
 233         entity.setScope("com");
 234         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 235         configurationEntity.setConfigBody(configData);
 236         configurationEntity.setConfigType("OTHER");
 237         configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
 238         configurationEntity.setDescription("test");
 239         entity.setConfigurationData(configurationEntity);
 240         policyData.add(entity);
 241                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 242                 HttpServletRequest request = mock(HttpServletRequest.class);
 243         HttpServletResponse response = mock(HttpServletResponse.class);
 244         PolicyController controller = mock(PolicyController.class);
 245         List<String> list = new ArrayList<>();
 246         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml', onlyFolders: false}}");
 247         for(int i =0; i < list.size(); i++){
 248                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 249             try {
 250                         when(request.getReader()).thenReturn(reader);
 251                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 252                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 253                         servlet.setPolicyController(controller);
 254                         servlet.setTestUserId("Test");
 255                         servlet.doPost(request, response);
 256                 } catch (Exception e1) {
 257                         logger.error("Exception Occured"+e1);
 258                         fail();
 259                 }
 260         }
 261         }
 262
 263         @SuppressWarnings("static-access")
 264         @Test
 265         public void editBRMSRawPolicyTest(){
 266                 List<Object> policyData = new ArrayList<>();
 267         String policyContent = "";
 268         String configData = "";
 269         try {
 270                         ClassLoader classLoader = getClass().getClassLoader();
 271                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
 272                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
 273                 } catch (Exception e1) {
 274                         logger.error("Exception Occured"+e1);
 275                 }
 276         PolicyEntity entity = new PolicyEntity();
 277         entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
 278         entity.setPolicyData(policyContent);
 279         entity.setScope("com");
 280         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 281         configurationEntity.setConfigBody(configData);
 282         configurationEntity.setConfigType("OTHER");
 283         configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
 284         configurationEntity.setDescription("test");
 285         entity.setConfigurationData(configurationEntity);
 286         policyData.add(entity);
 287                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 288                 HttpServletRequest request = mock(HttpServletRequest.class);
 289         HttpServletResponse response = mock(HttpServletResponse.class);
 290         PolicyController controller = mock(PolicyController.class);
 291         List<String> list = new ArrayList<>();
 292         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml', onlyFolders: false}}");
 293         for(int i =0; i < list.size(); i++){
 294                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 295             try {
 296                         when(request.getReader()).thenReturn(reader);
 297                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 298                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 299                         servlet.setPolicyController(controller);
 300                         servlet.setTestUserId("Test");
 301                         servlet.doPost(request, response);
 302                 } catch (Exception e1) {
 303                         logger.error("Exception Occured"+e1);
 304                         fail();
 305                 }
 306         }
 307         }
 308
 309         @SuppressWarnings("static-access")
 310         @Test
 311         public void editClosedLoopFaultPolicyTest(){
 312                 List<Object> policyData = new ArrayList<>();
 313         String policyContent = "";
 314         String configData = "";
 315         try {
 316                         ClassLoader classLoader = getClass().getClassLoader();
 317                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
 318                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
 319                 } catch (Exception e1) {
 320                         logger.error("Exception Occured"+e1);
 321                 }
 322         PolicyEntity entity = new PolicyEntity();
 323         entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
 324         entity.setPolicyData(policyContent);
 325         entity.setScope("com");
 326         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 327         configurationEntity.setConfigBody(configData);
 328         configurationEntity.setConfigType("JSON");
 329         configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
 330         configurationEntity.setDescription("test");
 331         entity.setConfigurationData(configurationEntity);
 332         policyData.add(entity);
 333                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 334                 HttpServletRequest request = mock(HttpServletRequest.class);
 335         HttpServletResponse response = mock(HttpServletResponse.class);
 336         PolicyController controller = mock(PolicyController.class);
 337         List<String> list = new ArrayList<>();
 338         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml', onlyFolders: false}}");
 339         for(int i =0; i < list.size(); i++){
 340                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 341             try {
 342                         when(request.getReader()).thenReturn(reader);
 343                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 344                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 345                         servlet.setPolicyController(controller);
 346                         servlet.setTestUserId("Test");
 347                         servlet.doPost(request, response);
 348                 } catch (Exception e1) {
 349                         logger.error("Exception Occured"+e1);
 350                         fail();
 351                 }
 352         }
 353         }
 354
 355         @SuppressWarnings("static-access")
 356         @Test
 357         public void editClosedLoopPMPolicyTest(){
 358                 List<Object> policyData = new ArrayList<>();
 359         String policyContent = "";
 360         String configData = "";
 361         try {
 362                         ClassLoader classLoader = getClass().getClassLoader();
 363                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
 364                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
 365                 } catch (Exception e1) {
 366                         logger.error("Exception Occured"+e1);
 367                 }
 368         PolicyEntity entity = new PolicyEntity();
 369         entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
 370         entity.setPolicyData(policyContent);
 371         entity.setScope("com");
 372         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 373         configurationEntity.setConfigBody(configData);
 374         configurationEntity.setConfigType("JSON");
 375         configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
 376         configurationEntity.setDescription("test");
 377         entity.setConfigurationData(configurationEntity);
 378         policyData.add(entity);
 379                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 380                 HttpServletRequest request = mock(HttpServletRequest.class);
 381         HttpServletResponse response = mock(HttpServletResponse.class);
 382         PolicyController controller = mock(PolicyController.class);
 383         List<String> list = new ArrayList<>();
 384         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml', onlyFolders: false}}");
 385         for(int i =0; i < list.size(); i++){
 386                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 387             try {
 388                         when(request.getReader()).thenReturn(reader);
 389                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 390                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 391                         servlet.setPolicyController(controller);
 392                         servlet.setTestUserId("Test");
 393                         servlet.doPost(request, response);
 394                 } catch (Exception e1) {
 395                         logger.error("Exception Occured"+e1);
 396                         fail();
 397                 }
 398         }
 399         }
 400
 401         @SuppressWarnings("static-access")
 402         @Test
 403         public void editMicroServicePolicyTest(){
 404                 GroupPolicyScopeList groupData = new  GroupPolicyScopeList();
 405                 groupData.setGroupName("Test");
 406                 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,closedLoopControlName=SampleClosedLoop");
 407                 List<Object> groupListData = new ArrayList<>();
 408                 groupListData.add(groupData);
 409                 commonClassDao = mock(CommonClassDao.class);
 410                 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
 411                 List<Object> policyData = new ArrayList<>();
 412         String policyContent = "";
 413         String configData = "";
 414         try {
 415                         ClassLoader classLoader = getClass().getClassLoader();
 416                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
 417                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
 418                 } catch (Exception e1) {
 419                         logger.error("Exception Occured"+e1);
 420                 }
 421         PolicyEntity entity = new PolicyEntity();
 422         entity.setPolicyName("Config_MS_vFirewall.1.xml");
 423         entity.setPolicyData(policyContent);
 424         entity.setScope("com");
 425         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 426         configurationEntity.setConfigBody(configData);
 427         configurationEntity.setConfigType("JSON");
 428         configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
 429         configurationEntity.setDescription("test");
 430         entity.setConfigurationData(configurationEntity);
 431         policyData.add(entity);
 432                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 433                 HttpServletRequest request = mock(HttpServletRequest.class);
 434         HttpServletResponse response = mock(HttpServletResponse.class);
 435         PolicyController controller = mock(PolicyController.class);
 436         List<String> list = new ArrayList<>();
 437         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
 438         for(int i =0; i < list.size(); i++){
 439                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 440             try {
 441                         when(request.getReader()).thenReturn(reader);
 442                         when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList", "resource=SampleResource,service=SampleService,type=SampleType,closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
 443                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 444                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 445                         servlet.setPolicyController(controller);
 446                         servlet.setTestUserId("Test");
 447                         servlet.doPost(request, response);
 448                 } catch (Exception e1) {
 449                         logger.error("Exception Occured"+e1);
 450                         fail();
 451                 }
 452         }
 453         }
 454
 455         @SuppressWarnings("static-access")
 456         @Test
 457         public void editFirewallPolicyTest(){
 458                 List<Object> policyData = new ArrayList<>();
 459         String policyContent = "";
 460         String configData = "";
 461         try {
 462                         ClassLoader classLoader = getClass().getClassLoader();
 463                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
 464                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
 465                 } catch (Exception e1) {
 466                         logger.error("Exception Occured"+e1);
 467                 }
 468         PolicyEntity entity = new PolicyEntity();
 469         entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
 470         entity.setPolicyData(policyContent);
 471         entity.setScope("com");
 472         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 473         configurationEntity.setConfigBody(configData);
 474         configurationEntity.setConfigType("JSON");
 475         configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
 476         configurationEntity.setDescription("test");
 477         entity.setConfigurationData(configurationEntity);
 478         policyData.add(entity);
 479                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 480                 HttpServletRequest request = mock(HttpServletRequest.class);
 481         HttpServletResponse response = mock(HttpServletResponse.class);
 482         PolicyController controller = mock(PolicyController.class);
 483         List<String> list = new ArrayList<>();
 484         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml', onlyFolders: false}}");
 485         for(int i =0; i < list.size(); i++){
 486                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 487             try {
 488                         when(request.getReader()).thenReturn(reader);
 489                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 490                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 491                         servlet.setPolicyController(controller);
 492                         servlet.setTestUserId("Test");
 493                         servlet.doPost(request, response);
 494                 } catch (Exception e1) {
 495                         logger.error("Exception Occured"+e1);
 496                         fail();
 497                 }
 498         }
 499         }
 500
 501         @SuppressWarnings("static-access")
 502         @Test
 503         public void editActionPolicyTest(){
 504                 List<Object> policyData = new ArrayList<>();
 505         String policyContent = "";
 506         String configData = "";
 507         try {
 508                         ClassLoader classLoader = getClass().getClassLoader();
 509                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
 510                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
 511                 } catch (Exception e1) {
 512                         logger.error("Exception Occured"+e1);
 513                 }
 514         PolicyEntity entity = new PolicyEntity();
 515         entity.setPolicyName("Action_TestActionPolicy.1.xml");
 516         entity.setPolicyData(policyContent);
 517         entity.setScope("com");
 518         ActionBodyEntity configurationEntity = new ActionBodyEntity();
 519         configurationEntity.setActionBody(configData);
 520         configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
 521         entity.setActionBodyEntity(configurationEntity);
 522         policyData.add(entity);
 523                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 524                 HttpServletRequest request = mock(HttpServletRequest.class);
 525         HttpServletResponse response = mock(HttpServletResponse.class);
 526         PolicyController controller = mock(PolicyController.class);
 527         List<String> list = new ArrayList<>();
 528         list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml', onlyFolders: false}}");
 529         for(int i =0; i < list.size(); i++){
 530                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 531             try {
 532                         when(request.getReader()).thenReturn(reader);
 533                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 534                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 535                         servlet.setPolicyController(controller);
 536                         servlet.setTestUserId("Test");
 537                         servlet.doPost(request, response);
 538                 } catch (Exception e1) {
 539                         logger.error("Exception Occured"+e1);
 540                         fail();
 541                 }
 542         }
 543         }
 544
 545         @SuppressWarnings("static-access")
 546         @Test
 547         public void editDecisionPolicyTest(){
 548                 List<Object> policyData = new ArrayList<>();
 549         String policyContent = "";
 550         try {
 551                         ClassLoader classLoader = getClass().getClassLoader();
 552                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
 553                 } catch (Exception e1) {
 554                         logger.error("Exception Occured"+e1);
 555                 }
 556         PolicyEntity entity = new PolicyEntity();
 557         entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
 558         entity.setPolicyData(policyContent);
 559         entity.setScope("com");
 560         policyData.add(entity);
 561                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 562                 HttpServletRequest request = mock(HttpServletRequest.class);
 563         HttpServletResponse response = mock(HttpServletResponse.class);
 564         PolicyController controller = mock(PolicyController.class);
 565         List<String> list = new ArrayList<>();
 566         list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml', onlyFolders: false}}");
 567         for(int i =0; i < list.size(); i++){
 568                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 569             try {
 570                         when(request.getReader()).thenReturn(reader);
 571                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 572                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 573                         servlet.setPolicyController(controller);
 574                         servlet.setTestUserId("Test");
 575                         servlet.doPost(request, response);
 576                 } catch (Exception e1) {
 577                         logger.error("Exception Occured"+e1);
 578                         fail();
 579                 }
 580         }
 581         }
 582 }