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