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