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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Engine
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.policy.admin;
  21
  22 import static org.junit.Assert.fail;
  23
  24 import java.io.BufferedReader;
  25 import java.io.File;
  26 import java.io.StringReader;
  27 import java.util.ArrayList;
  28 import java.util.Collections;
  29 import java.util.List;
  30
  31 import javax.servlet.ServletConfig;
  32 import javax.servlet.http.HttpServletRequest;
  33 import javax.servlet.http.HttpServletResponse;
  34
  35 import org.apache.commons.io.IOUtils;
  36 import org.junit.Before;
  37 import org.junit.Test;
  38 import org.mockito.Mockito;
  39 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  40 import org.onap.policy.common.logging.flexlogger.Logger;
  41 import org.onap.policy.controller.CreateDcaeMicroServiceController;
  42 import org.onap.policy.controller.PolicyController;
  43 import org.onap.policy.rest.dao.CommonClassDao;
  44 import org.onap.policy.rest.jpa.ActionBodyEntity;
  45 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
  46 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  47 import org.onap.policy.rest.jpa.PolicyEditorScopes;
  48 import org.onap.policy.rest.jpa.PolicyEntity;
  49 import org.onap.policy.rest.jpa.PolicyVersion;
  50 import org.onap.policy.rest.jpa.UserInfo;
  51 import org.openecomp.policy.model.Roles;
  52
  53 public class PolicyManagerServletTest extends Mockito{
  54
  55         private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
  56         private List<String> headers = new ArrayList<String>();
  57
  58         private static List<Object> rolesdata;
  59         private static List<Object> basePolicyData;
  60         private static List<Object> policyEditorScopes;
  61         private static List<Object> policyVersion;
  62         private static CommonClassDao commonClassDao;
  63
  64         @Before
  65         public void setUp() throws Exception{
  66                 logger.info("setUp: Entering");
  67                 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         @SuppressWarnings("static-access")
 143         @Test
 144         public void testDescribePolicy(){
 145                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 146                 HttpServletRequest request = mock(HttpServletRequest.class);
 147         HttpServletResponse response = mock(HttpServletResponse.class);
 148         PolicyController controller = mock(PolicyController.class);
 149         PolicyManagerServlet.setjUnit(true);
 150         BufferedReader reader = new BufferedReader(new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
 151         try {
 152                         when(request.getReader()).thenReturn(reader);
 153                         String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
 154                         when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
 155                         servlet.setPolicyController(controller);
 156                         servlet.doPost(request, response);
 157                 } catch (Exception e1) {
 158                         logger.error("Exception Occured"+e1);
 159                         fail();
 160                 }
 161         }
 162
 163
 164         @SuppressWarnings("static-access")
 165         @Test
 166         public void testPolicyScopeList(){
 167                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 168                 HttpServletRequest request = mock(HttpServletRequest.class);
 169         HttpServletResponse response = mock(HttpServletResponse.class);
 170         PolicyController controller = mock(PolicyController.class);
 171         PolicyManagerServlet.setjUnit(true);
 172         List<String> list = new ArrayList<>();
 173         list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
 174         list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
 175         for(int i =0; i < list.size(); i++){
 176                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 177             try {
 178                         when(request.getReader()).thenReturn(reader);
 179                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 180                         when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
 181                         when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null)).thenReturn(policyEditorScopes);
 182                         when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null)).thenReturn(policyVersion);
 183                         servlet.setPolicyController(controller);
 184                         servlet.setTestUserId("Test");
 185                         servlet.doPost(request, response);
 186                 } catch (Exception e1) {
 187                         logger.error("Exception Occured"+e1);
 188                         fail();
 189                 }
 190         }
 191         }
 192
 193         @SuppressWarnings("static-access")
 194         @Test
 195         public void editBasePolicyTest(){
 196                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 197                 HttpServletRequest request = mock(HttpServletRequest.class);
 198         HttpServletResponse response = mock(HttpServletResponse.class);
 199         PolicyController controller = mock(PolicyController.class);
 200         PolicyManagerServlet.setjUnit(true);
 201         List<String> list = new ArrayList<>();
 202         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
 203         for(int i =0; i < list.size(); i++){
 204                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 205             try {
 206                         when(request.getReader()).thenReturn(reader);
 207                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 208                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(basePolicyData);
 209                         servlet.setPolicyController(controller);
 210                         servlet.setTestUserId("Test");
 211                         servlet.doPost(request, response);
 212                 } catch (Exception e1) {
 213                         logger.error("Exception Occured"+e1);
 214                         fail();
 215                 }
 216         }
 217         }
 218
 219         @SuppressWarnings("static-access")
 220         @Test
 221         public void editBRMSParamPolicyTest(){
 222                 List<Object> policyData = new ArrayList<>();
 223         String policyContent = "";
 224         String configData = "";
 225         try {
 226                         ClassLoader classLoader = getClass().getClassLoader();
 227                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 228                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
 229                 } catch (Exception e1) {
 230                         logger.error("Exception Occured"+e1);
 231                 }
 232         PolicyEntity entity = new PolicyEntity();
 233         entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 234         entity.setPolicyData(policyContent);
 235         entity.setScope("com");
 236         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 237         configurationEntity.setConfigBody(configData);
 238         configurationEntity.setConfigType("OTHER");
 239         configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
 240         configurationEntity.setDescription("test");
 241         entity.setConfigurationData(configurationEntity);
 242         policyData.add(entity);
 243                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 244                 HttpServletRequest request = mock(HttpServletRequest.class);
 245         HttpServletResponse response = mock(HttpServletResponse.class);
 246         PolicyController controller = mock(PolicyController.class);
 247         PolicyManagerServlet.setjUnit(true);
 248         List<String> list = new ArrayList<>();
 249         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml', onlyFolders: false}}");
 250         for(int i =0; i < list.size(); i++){
 251                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 252             try {
 253                         when(request.getReader()).thenReturn(reader);
 254                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 255                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 256                         servlet.setPolicyController(controller);
 257                         servlet.setTestUserId("Test");
 258                         servlet.doPost(request, response);
 259                 } catch (Exception e1) {
 260                         logger.error("Exception Occured"+e1);
 261                         fail();
 262                 }
 263         }
 264         }
 265
 266         @SuppressWarnings("static-access")
 267         @Test
 268         public void editBRMSRawPolicyTest(){
 269                 List<Object> policyData = new ArrayList<>();
 270         String policyContent = "";
 271         String configData = "";
 272         try {
 273                         ClassLoader classLoader = getClass().getClassLoader();
 274                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
 275                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
 276                 } catch (Exception e1) {
 277                         logger.error("Exception Occured"+e1);
 278                 }
 279         PolicyEntity entity = new PolicyEntity();
 280         entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
 281         entity.setPolicyData(policyContent);
 282         entity.setScope("com");
 283         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 284         configurationEntity.setConfigBody(configData);
 285         configurationEntity.setConfigType("OTHER");
 286         configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
 287         configurationEntity.setDescription("test");
 288         entity.setConfigurationData(configurationEntity);
 289         policyData.add(entity);
 290                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 291                 HttpServletRequest request = mock(HttpServletRequest.class);
 292         HttpServletResponse response = mock(HttpServletResponse.class);
 293         PolicyController controller = mock(PolicyController.class);
 294         PolicyManagerServlet.setjUnit(true);
 295         List<String> list = new ArrayList<>();
 296         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml', onlyFolders: false}}");
 297         for(int i =0; i < list.size(); i++){
 298                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 299             try {
 300                         when(request.getReader()).thenReturn(reader);
 301                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 302                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 303                         servlet.setPolicyController(controller);
 304                         servlet.setTestUserId("Test");
 305                         servlet.doPost(request, response);
 306                 } catch (Exception e1) {
 307                         logger.error("Exception Occured"+e1);
 308                         fail();
 309                 }
 310         }
 311         }
 312
 313         @SuppressWarnings("static-access")
 314         @Test
 315         public void editClosedLoopFaultPolicyTest(){
 316                 List<Object> policyData = new ArrayList<>();
 317         String policyContent = "";
 318         String configData = "";
 319         try {
 320                         ClassLoader classLoader = getClass().getClassLoader();
 321                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
 322                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
 323                 } catch (Exception e1) {
 324                         logger.error("Exception Occured"+e1);
 325                 }
 326         PolicyEntity entity = new PolicyEntity();
 327         entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
 328         entity.setPolicyData(policyContent);
 329         entity.setScope("com");
 330         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 331         configurationEntity.setConfigBody(configData);
 332         configurationEntity.setConfigType("JSON");
 333         configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
 334         configurationEntity.setDescription("test");
 335         entity.setConfigurationData(configurationEntity);
 336         policyData.add(entity);
 337                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 338                 HttpServletRequest request = mock(HttpServletRequest.class);
 339         HttpServletResponse response = mock(HttpServletResponse.class);
 340         PolicyController controller = mock(PolicyController.class);
 341         PolicyManagerServlet.setjUnit(true);
 342         List<String> list = new ArrayList<>();
 343         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml', onlyFolders: false}}");
 344         for(int i =0; i < list.size(); i++){
 345                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 346             try {
 347                         when(request.getReader()).thenReturn(reader);
 348                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 349                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 350                         servlet.setPolicyController(controller);
 351                         servlet.setTestUserId("Test");
 352                         servlet.doPost(request, response);
 353                 } catch (Exception e1) {
 354                         logger.error("Exception Occured"+e1);
 355                         fail();
 356                 }
 357         }
 358         }
 359
 360         @SuppressWarnings("static-access")
 361         @Test
 362         public void editClosedLoopPMPolicyTest(){
 363                 List<Object> policyData = new ArrayList<>();
 364         String policyContent = "";
 365         String configData = "";
 366         try {
 367                         ClassLoader classLoader = getClass().getClassLoader();
 368                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
 369                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
 370                 } catch (Exception e1) {
 371                         logger.error("Exception Occured"+e1);
 372                 }
 373         PolicyEntity entity = new PolicyEntity();
 374         entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
 375         entity.setPolicyData(policyContent);
 376         entity.setScope("com");
 377         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 378         configurationEntity.setConfigBody(configData);
 379         configurationEntity.setConfigType("JSON");
 380         configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
 381         configurationEntity.setDescription("test");
 382         entity.setConfigurationData(configurationEntity);
 383         policyData.add(entity);
 384                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 385                 HttpServletRequest request = mock(HttpServletRequest.class);
 386         HttpServletResponse response = mock(HttpServletResponse.class);
 387         PolicyController controller = mock(PolicyController.class);
 388         PolicyManagerServlet.setjUnit(true);
 389         List<String> list = new ArrayList<>();
 390         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml', onlyFolders: false}}");
 391         for(int i =0; i < list.size(); i++){
 392                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 393             try {
 394                         when(request.getReader()).thenReturn(reader);
 395                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 396                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 397                         servlet.setPolicyController(controller);
 398                         servlet.setTestUserId("Test");
 399                         servlet.doPost(request, response);
 400                 } catch (Exception e1) {
 401                         logger.error("Exception Occured"+e1);
 402                         fail();
 403                 }
 404         }
 405         }
 406
 407         @SuppressWarnings("static-access")
 408         @Test
 409         public void editMicroServicePolicyTest(){
 410                 GroupPolicyScopeList groupData = new  GroupPolicyScopeList();
 411                 groupData.setGroupName("Test");
 412                 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,closedLoopControlName=SampleClosedLoop");
 413                 List<Object> groupListData = new ArrayList<>();
 414                 groupListData.add(groupData);
 415                 commonClassDao = mock(CommonClassDao.class);
 416                 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
 417                 List<Object> policyData = new ArrayList<>();
 418         String policyContent = "";
 419         String configData = "";
 420         try {
 421                         ClassLoader classLoader = getClass().getClassLoader();
 422                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
 423                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
 424                 } catch (Exception e1) {
 425                         logger.error("Exception Occured"+e1);
 426                 }
 427         PolicyEntity entity = new PolicyEntity();
 428         entity.setPolicyName("Config_MS_vFirewall.1.xml");
 429         entity.setPolicyData(policyContent);
 430         entity.setScope("com");
 431         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 432         configurationEntity.setConfigBody(configData);
 433         configurationEntity.setConfigType("JSON");
 434         configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
 435         configurationEntity.setDescription("test");
 436         entity.setConfigurationData(configurationEntity);
 437         policyData.add(entity);
 438                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 439                 HttpServletRequest request = mock(HttpServletRequest.class);
 440         HttpServletResponse response = mock(HttpServletResponse.class);
 441         PolicyController controller = mock(PolicyController.class);
 442         PolicyManagerServlet.setjUnit(true);
 443         List<String> list = new ArrayList<>();
 444         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
 445         for(int i =0; i < list.size(); i++){
 446                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 447             try {
 448                         when(request.getReader()).thenReturn(reader);
 449                         when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList", "resource=SampleResource,service=SampleService,type=SampleType,closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
 450                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 451                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 452                         servlet.setPolicyController(controller);
 453                         servlet.setTestUserId("Test");
 454                         servlet.doPost(request, response);
 455                 } catch (Exception e1) {
 456                         logger.error("Exception Occured"+e1);
 457                         fail();
 458                 }
 459         }
 460         }
 461
 462         @SuppressWarnings("static-access")
 463         @Test
 464         public void editFirewallPolicyTest(){
 465                 List<Object> policyData = new ArrayList<>();
 466         String policyContent = "";
 467         String configData = "";
 468         try {
 469                         ClassLoader classLoader = getClass().getClassLoader();
 470                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
 471                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
 472                 } catch (Exception e1) {
 473                         logger.error("Exception Occured"+e1);
 474                 }
 475         PolicyEntity entity = new PolicyEntity();
 476         entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
 477         entity.setPolicyData(policyContent);
 478         entity.setScope("com");
 479         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 480         configurationEntity.setConfigBody(configData);
 481         configurationEntity.setConfigType("JSON");
 482         configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
 483         configurationEntity.setDescription("test");
 484         entity.setConfigurationData(configurationEntity);
 485         policyData.add(entity);
 486                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 487                 HttpServletRequest request = mock(HttpServletRequest.class);
 488         HttpServletResponse response = mock(HttpServletResponse.class);
 489         PolicyController controller = mock(PolicyController.class);
 490         PolicyManagerServlet.setjUnit(true);
 491         List<String> list = new ArrayList<>();
 492         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml', onlyFolders: false}}");
 493         for(int i =0; i < list.size(); i++){
 494                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 495             try {
 496                         when(request.getReader()).thenReturn(reader);
 497                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 498                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 499                         servlet.setPolicyController(controller);
 500                         servlet.setTestUserId("Test");
 501                         servlet.doPost(request, response);
 502                 } catch (Exception e1) {
 503                         logger.error("Exception Occured"+e1);
 504                         fail();
 505                 }
 506         }
 507         }
 508
 509         @SuppressWarnings("static-access")
 510         @Test
 511         public void editActionPolicyTest(){
 512                 List<Object> policyData = new ArrayList<>();
 513         String policyContent = "";
 514         String configData = "";
 515         try {
 516                         ClassLoader classLoader = getClass().getClassLoader();
 517                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
 518                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
 519                 } catch (Exception e1) {
 520                         logger.error("Exception Occured"+e1);
 521                 }
 522         PolicyEntity entity = new PolicyEntity();
 523         entity.setPolicyName("Action_TestActionPolicy.1.xml");
 524         entity.setPolicyData(policyContent);
 525         entity.setScope("com");
 526         ActionBodyEntity configurationEntity = new ActionBodyEntity();
 527         configurationEntity.setActionBody(configData);
 528         configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
 529         entity.setActionBodyEntity(configurationEntity);
 530         policyData.add(entity);
 531                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 532                 HttpServletRequest request = mock(HttpServletRequest.class);
 533         HttpServletResponse response = mock(HttpServletResponse.class);
 534         PolicyController controller = mock(PolicyController.class);
 535         PolicyManagerServlet.setjUnit(true);
 536         List<String> list = new ArrayList<>();
 537         list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml', onlyFolders: false}}");
 538         for(int i =0; i < list.size(); i++){
 539                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 540             try {
 541                         when(request.getReader()).thenReturn(reader);
 542                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 543                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 544                         servlet.setPolicyController(controller);
 545                         servlet.setTestUserId("Test");
 546                         servlet.doPost(request, response);
 547                 } catch (Exception e1) {
 548                         logger.error("Exception Occured"+e1);
 549                         fail();
 550                 }
 551         }
 552         }
 553
 554         @SuppressWarnings("static-access")
 555         @Test
 556         public void editDecisionPolicyTest(){
 557                 List<Object> policyData = new ArrayList<>();
 558         String policyContent = "";
 559         try {
 560                         ClassLoader classLoader = getClass().getClassLoader();
 561                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
 562                 } catch (Exception e1) {
 563                         logger.error("Exception Occured"+e1);
 564                 }
 565         PolicyEntity entity = new PolicyEntity();
 566         entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
 567         entity.setPolicyData(policyContent);
 568         entity.setScope("com");
 569         policyData.add(entity);
 570                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 571                 HttpServletRequest request = mock(HttpServletRequest.class);
 572         HttpServletResponse response = mock(HttpServletResponse.class);
 573         PolicyController controller = mock(PolicyController.class);
 574         PolicyManagerServlet.setjUnit(true);
 575         List<String> list = new ArrayList<>();
 576         list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml', onlyFolders: false}}");
 577         for(int i =0; i < list.size(); i++){
 578                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 579             try {
 580                         when(request.getReader()).thenReturn(reader);
 581                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 582                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 583                         servlet.setPolicyController(controller);
 584                         servlet.setTestUserId("Test");
 585                         servlet.doPost(request, response);
 586                 } catch (Exception e1) {
 587                         logger.error("Exception Occured"+e1);
 588                         fail();
 589                 }
 590         }
 591         }
 592 }