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

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