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