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-2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (C) 2019 Samsung
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.admin;
  24
  25 import static org.junit.Assert.assertTrue;
  26 import static org.junit.Assert.fail;
  27
  28 import java.io.BufferedReader;
  29 import java.io.File;
  30 import java.io.StringReader;
  31 import java.util.ArrayList;
  32 import java.util.Collections;
  33 import java.util.List;
  34
  35 import javax.servlet.ServletConfig;
  36 import javax.servlet.http.HttpServletRequest;
  37 import javax.servlet.http.HttpSession;
  38
  39 import org.apache.commons.io.IOUtils;
  40 import org.junit.Before;
  41 import org.junit.Test;
  42 import org.mockito.Mockito;
  43 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  44 import org.onap.policy.common.logging.flexlogger.Logger;
  45 import org.onap.policy.controller.CreateDcaeMicroServiceController;
  46 import org.onap.policy.controller.PolicyController;
  47 import org.onap.policy.model.Roles;
  48 import org.onap.policy.rest.dao.CommonClassDao;
  49 import org.onap.policy.rest.jpa.ActionBodyEntity;
  50 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
  51 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  52 import org.onap.policy.rest.jpa.PolicyEditorScopes;
  53 import org.onap.policy.rest.jpa.PolicyEntity;
  54 import org.onap.policy.rest.jpa.PolicyVersion;
  55 import org.onap.policy.rest.jpa.UserInfo;
  56 import org.onap.portalsdk.core.domain.User;
  57 import org.onap.portalsdk.core.util.SystemProperties;
  58 import org.springframework.mock.web.MockHttpServletResponse;
  59
  60 public class PolicyManagerServletTest extends Mockito {
  61
  62     private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
  63     private List<String> headers = new ArrayList<String>();
  64
  65     private static List<Object> rolesdata;
  66     private static List<Object> basePolicyData;
  67     private static List<Object> policyEditorScopes;
  68     private static List<Object> policyVersion;
  69     private static CommonClassDao commonClassDao;
  70     private ConfigurationDataEntity configurationEntity;
  71     private HttpServletRequest request;
  72     private MockHttpServletResponse response;
  73
  74     @Before
  75     public void setUp() throws Exception {
  76         logger.info("setUp: Entering");
  77
  78         request = mock(HttpServletRequest.class);
  79         response = new MockHttpServletResponse();
  80
  81         PolicyController.setjUnit(true);
  82         UserInfo userinfo = new UserInfo();
  83         userinfo.setUserLoginId("Test");
  84         userinfo.setUserName("Test");
  85         // Roles Data
  86         rolesdata = new ArrayList<>();
  87         Roles roles = new Roles();
  88         roles.setLoginId("Test");
  89         roles.setRole("super-admin");
  90         Roles roles1 = new Roles();
  91         roles1.setId(1);
  92         roles1.setName("Test");
  93         assertTrue("Test".equals(roles1.getName()));
  94         roles1.setLoginId("Test");
  95         roles1.setRole("admin");
  96         roles1.setScope("['com','Test']");
  97         rolesdata.add(roles);
  98         rolesdata.add(roles1);
  99
 100         // PolicyEntity Data
 101         basePolicyData = new ArrayList<>();
 102         String policyContent = "";
 103         try {
 104             ClassLoader classLoader = getClass().getClassLoader();
 105             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
 106         } catch (Exception e1) {
 107             logger.error("Exception Occured" + e1);
 108         }
 109         PolicyEntity entity = new PolicyEntity();
 110         entity.setPolicyName("Config_SampleTest.1.xml");
 111         entity.setPolicyData(policyContent);
 112         entity.setScope("com");
 113         configurationEntity = new ConfigurationDataEntity();
 114         configurationEntity.setConfigBody("Sample Test");
 115         configurationEntity.setConfigType("OTHER");
 116         configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
 117         configurationEntity.setDescription("test");
 118         entity.setConfigurationData(configurationEntity);
 119         basePolicyData.add(entity);
 120
 121         // PolicyEditorScopes data
 122         policyEditorScopes = new ArrayList<>();
 123         PolicyEditorScopes scopes = new PolicyEditorScopes();
 124         scopes.setScopeName("com");
 125         scopes.setUserCreatedBy(userinfo);
 126         scopes.setUserModifiedBy(userinfo);
 127         PolicyEditorScopes scopes1 = new PolicyEditorScopes();
 128         scopes1.setScopeName("com\\Test");
 129         scopes1.setUserCreatedBy(userinfo);
 130         scopes1.setUserModifiedBy(userinfo);
 131         policyEditorScopes.add(scopes);
 132         policyEditorScopes.add(scopes1);
 133
 134         // PolicyVersion data
 135         policyVersion = new ArrayList<>();
 136         PolicyVersion policy = new PolicyVersion();
 137         policy.setPolicyName("com\\Config_SampleTest1206");
 138         policy.setActiveVersion(1);
 139         policy.setHigherVersion(1);
 140         policy.setCreatedBy("Test");
 141         policy.setModifiedBy("Test");
 142         policyVersion.add(policy);
 143
 144         HttpSession mockSession = mock(HttpSession.class);
 145         User user = new User();
 146         user.setOrgUserId("Test");
 147         Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
 148         Mockito.when(request.getSession(false)).thenReturn(mockSession);
 149         commonClassDao = mock(CommonClassDao.class);
 150
 151     }
 152
 153     @Test
 154     public void testInit() {
 155         PolicyManagerServlet servlet = new PolicyManagerServlet();
 156         ServletConfig servletConfig = mock(ServletConfig.class);
 157         try {
 158             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 159             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 160             System.setProperty("xacml.rest.admin.closedLoopJSON",
 161                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 162                             + "resources" + File.separator + "JSONConfig.json");
 163             servlet.init(servletConfig);
 164
 165             assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
 166             assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
 167
 168         } catch (Exception e1) {
 169             logger.error("Exception Occured" + e1);
 170             fail();
 171         }
 172     }
 173
 174     @Test
 175     public void testBadInitJson() {
 176         PolicyManagerServlet servlet = new PolicyManagerServlet();
 177         ServletConfig servletConfig = mock(ServletConfig.class);
 178         try {
 179             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 180             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 181             System.setProperty("xacml.rest.admin.closedLoopJSON",
 182                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 183                             + "resources" + File.separator + "JSONConfig.foo");
 184             servlet.init(servletConfig);
 185         } catch (Exception e1) {
 186             logger.error("Exception Occured" + e1);
 187             fail();
 188         }
 189     }
 190
 191     @Test
 192     public void testBadInitJsonInvalidFile() {
 193         PolicyManagerServlet servlet = new PolicyManagerServlet();
 194         ServletConfig servletConfig = mock(ServletConfig.class);
 195         try {
 196             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 197             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 198             System.setProperty("xacml.rest.admin.closedLoopJSON",
 199                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 200                             + "resources" + File.separator + "IDonotExist.json");
 201             servlet.init(servletConfig);
 202         } catch (Exception e1) {
 203             logger.error("Exception Occured" + e1);
 204             fail();
 205         }
 206     }
 207
 208     @SuppressWarnings("static-access")
 209     @Test
 210     public void testDescribePolicy() {
 211         PolicyManagerServlet servlet = new PolicyManagerServlet();
 212         PolicyController controller = mock(PolicyController.class);
 213         BufferedReader reader = new BufferedReader(
 214                 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
 215         try {
 216             when(request.getReader()).thenReturn(reader);
 217             String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
 218             when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
 219             servlet.setPolicyController(controller);
 220             servlet.doPost(request, response);
 221         } catch (Exception e1) {
 222             logger.error("Exception Occured" + e1);
 223             fail();
 224         }
 225     }
 226
 227     @SuppressWarnings("static-access")
 228     @Test
 229     public void testPolicyScopeList() {
 230         PolicyManagerServlet servlet = new PolicyManagerServlet();
 231         PolicyController controller = mock(PolicyController.class);
 232         List<String> list = new ArrayList<>();
 233         list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
 234         list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
 235         for (int i = 0; i < list.size(); i++) {
 236             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 237             try {
 238                 when(request.getReader()).thenReturn(reader);
 239                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 240                 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
 241                 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
 242                         .thenReturn(policyEditorScopes);
 243                 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
 244                         .thenReturn(policyVersion);
 245                 servlet.setPolicyController(controller);
 246                 servlet.setTestUserId("Test");
 247                 servlet.doPost(request, response);
 248             } catch (Exception e1) {
 249                 logger.error("Exception Occured" + e1);
 250                 fail();
 251             }
 252         }
 253     }
 254
 255     @SuppressWarnings("static-access")
 256     @Test
 257     public void editBasePolicyTest() {
 258         PolicyManagerServlet servlet = new PolicyManagerServlet();
 259         PolicyController controller = mock(PolicyController.class);
 260         List<String> list = new ArrayList<>();
 261         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
 262         for (int i = 0; i < list.size(); i++) {
 263             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 264             try {
 265                 when(request.getReader()).thenReturn(reader);
 266                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 267                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 268                         null)).thenReturn(basePolicyData);
 269                 servlet.setPolicyController(controller);
 270                 servlet.setTestUserId("Test");
 271                 servlet.doPost(request, response);
 272             } catch (Exception e1) {
 273                 logger.error("Exception Occured" + e1);
 274                 fail();
 275             }
 276         }
 277     }
 278
 279     @SuppressWarnings("static-access")
 280     @Test
 281     public void editBRMSParamPolicyTest() {
 282         List<Object> policyData = new ArrayList<>();
 283         String policyContent = "";
 284         String configData = "";
 285         try {
 286             ClassLoader classLoader = getClass().getClassLoader();
 287             policyContent =
 288                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 289             configData = IOUtils
 290                     .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
 291         } catch (Exception e1) {
 292             logger.error("Exception Occured" + e1);
 293         }
 294         PolicyEntity entity = new PolicyEntity();
 295         entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 296         entity.setPolicyData(policyContent);
 297         entity.setScope("com");
 298         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 299         configurationEntity.setConfigBody(configData);
 300         configurationEntity.setConfigType("OTHER");
 301         configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
 302         configurationEntity.setDescription("test");
 303         entity.setConfigurationData(configurationEntity);
 304         policyData.add(entity);
 305         PolicyManagerServlet servlet = new PolicyManagerServlet();
 306         PolicyController controller = mock(PolicyController.class);
 307         List<String> list = new ArrayList<>();
 308         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
 309                 + " onlyFolders: false}}");
 310         for (int i = 0; i < list.size(); i++) {
 311             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 312             try {
 313                 when(request.getReader()).thenReturn(reader);
 314                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 315                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 316                         null)).thenReturn(policyData);
 317                 servlet.setPolicyController(controller);
 318                 servlet.setTestUserId("Test");
 319                 servlet.doPost(request, response);
 320             } catch (Exception e1) {
 321                 logger.error("Exception Occured" + e1);
 322                 fail();
 323             }
 324         }
 325     }
 326
 327     @SuppressWarnings("static-access")
 328     @Test
 329     public void editBRMSRawPolicyTest() {
 330         List<Object> policyData = new ArrayList<>();
 331         String policyContent = "";
 332         String configData = "";
 333         try {
 334             ClassLoader classLoader = getClass().getClassLoader();
 335             policyContent =
 336                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
 337             configData =
 338                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
 339         } catch (Exception e1) {
 340             logger.error("Exception Occured" + e1);
 341         }
 342         PolicyEntity entity = new PolicyEntity();
 343         entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
 344         entity.setPolicyData(policyContent);
 345         entity.setScope("com");
 346         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 347         configurationEntity.setConfigBody(configData);
 348         configurationEntity.setConfigType("OTHER");
 349         configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
 350         configurationEntity.setDescription("test");
 351         entity.setConfigurationData(configurationEntity);
 352         policyData.add(entity);
 353         PolicyManagerServlet servlet = new PolicyManagerServlet();
 354         PolicyController controller = mock(PolicyController.class);
 355         List<String> list = new ArrayList<>();
 356         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
 357                 + " onlyFolders: false}}");
 358         for (int i = 0; i < list.size(); i++) {
 359             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 360             try {
 361                 when(request.getReader()).thenReturn(reader);
 362                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 363                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 364                         null)).thenReturn(policyData);
 365                 servlet.setPolicyController(controller);
 366                 servlet.setTestUserId("Test");
 367                 servlet.doPost(request, response);
 368             } catch (Exception e1) {
 369                 logger.error("Exception Occured" + e1);
 370                 fail();
 371             }
 372         }
 373     }
 374
 375     @SuppressWarnings("static-access")
 376     @Test
 377     public void editClosedLoopFaultPolicyTest() {
 378         List<Object> policyData = new ArrayList<>();
 379         String policyContent = "";
 380         String configData = "";
 381         try {
 382             ClassLoader classLoader = getClass().getClassLoader();
 383             policyContent =
 384                     IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
 385             configData =
 386                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
 387         } catch (Exception e1) {
 388             logger.error("Exception Occured" + e1);
 389         }
 390         PolicyEntity entity = new PolicyEntity();
 391         entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
 392         entity.setPolicyData(policyContent);
 393         entity.setScope("com");
 394         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 395         configurationEntity.setConfigBody(configData);
 396         configurationEntity.setConfigType("JSON");
 397         configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
 398         configurationEntity.setDescription("test");
 399         entity.setConfigurationData(configurationEntity);
 400         policyData.add(entity);
 401         PolicyManagerServlet servlet = new PolicyManagerServlet();
 402         PolicyController controller = mock(PolicyController.class);
 403         List<String> list = new ArrayList<>();
 404         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
 405                 + " onlyFolders: false}}");
 406         for (int i = 0; i < list.size(); i++) {
 407             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 408             try {
 409                 when(request.getReader()).thenReturn(reader);
 410                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 411                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 412                         null)).thenReturn(policyData);
 413                 servlet.setPolicyController(controller);
 414                 servlet.setTestUserId("Test");
 415                 servlet.doPost(request, response);
 416             } catch (Exception e1) {
 417                 logger.error("Exception Occured" + e1);
 418                 fail();
 419             }
 420         }
 421     }
 422
 423     @SuppressWarnings("static-access")
 424     @Test
 425     public void editClosedLoopPMPolicyTest() {
 426         List<Object> policyData = new ArrayList<>();
 427         String policyContent = "";
 428         String configData = "";
 429         try {
 430             ClassLoader classLoader = getClass().getClassLoader();
 431             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
 432             configData =
 433                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
 434         } catch (Exception e1) {
 435             logger.error("Exception Occured" + e1);
 436         }
 437         PolicyEntity entity = new PolicyEntity();
 438         entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
 439         entity.setPolicyData(policyContent);
 440         entity.setScope("com");
 441         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 442         configurationEntity.setConfigBody(configData);
 443         configurationEntity.setConfigType("JSON");
 444         configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
 445         configurationEntity.setDescription("test");
 446         entity.setConfigurationData(configurationEntity);
 447         policyData.add(entity);
 448         PolicyManagerServlet servlet = new PolicyManagerServlet();
 449         PolicyController controller = mock(PolicyController.class);
 450         List<String> list = new ArrayList<>();
 451         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
 452                 + " onlyFolders: false}}");
 453         for (int i = 0; i < list.size(); i++) {
 454             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 455             try {
 456                 when(request.getReader()).thenReturn(reader);
 457                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 458                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 459                         null)).thenReturn(policyData);
 460                 servlet.setPolicyController(controller);
 461                 servlet.setTestUserId("Test");
 462                 servlet.doPost(request, response);
 463             } catch (Exception e1) {
 464                 logger.error("Exception Occured" + e1);
 465                 fail();
 466             }
 467         }
 468     }
 469
 470     @SuppressWarnings("static-access")
 471     @Test
 472     public void editMicroServicePolicyTest() {
 473         GroupPolicyScopeList groupData = new GroupPolicyScopeList();
 474         groupData.setGroupName("Test");
 475         groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
 476                 + "closedLoopControlName=SampleClosedLoop");
 477         List<Object> groupListData = new ArrayList<>();
 478         groupListData.add(groupData);
 479         commonClassDao = mock(CommonClassDao.class);
 480         CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
 481         List<Object> policyData = new ArrayList<>();
 482         String policyContent = "";
 483         String configData = "";
 484         try {
 485             ClassLoader classLoader = getClass().getClassLoader();
 486             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
 487             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
 488         } catch (Exception e1) {
 489             logger.error("Exception Occured" + e1);
 490         }
 491         PolicyEntity entity = new PolicyEntity();
 492         entity.setPolicyName("Config_MS_vFirewall.1.xml");
 493         entity.setPolicyData(policyContent);
 494         entity.setScope("com");
 495         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 496         configurationEntity.setConfigBody(configData);
 497         configurationEntity.setConfigType("JSON");
 498         configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
 499         configurationEntity.setDescription("test");
 500         entity.setConfigurationData(configurationEntity);
 501         policyData.add(entity);
 502         PolicyManagerServlet servlet = new PolicyManagerServlet();
 503         PolicyController controller = mock(PolicyController.class);
 504         List<String> list = new ArrayList<>();
 505         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
 506         for (int i = 0; i < list.size(); i++) {
 507             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 508             try {
 509                 when(request.getReader()).thenReturn(reader);
 510                 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
 511                         "resource=SampleResource,service=SampleService,type=SampleType,"
 512                                 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
 513                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 514                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 515                         null)).thenReturn(policyData);
 516                 servlet.setPolicyController(controller);
 517                 servlet.setTestUserId("Test");
 518                 servlet.doPost(request, response);
 519             } catch (Exception e1) {
 520                 logger.error("Exception Occured" + e1);
 521                 fail();
 522             }
 523         }
 524     }
 525
 526     @SuppressWarnings("static-access")
 527     @Test
 528     public void editFirewallPolicyTest() {
 529         List<Object> policyData = new ArrayList<>();
 530         String policyContent = "";
 531         String configData = "";
 532         try {
 533             ClassLoader classLoader = getClass().getClassLoader();
 534             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
 535             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
 536         } catch (Exception e1) {
 537             logger.error("Exception Occured" + e1);
 538         }
 539         PolicyEntity entity = new PolicyEntity();
 540         entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
 541         entity.setPolicyData(policyContent);
 542         entity.setScope("com");
 543         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 544         configurationEntity.setConfigBody(configData);
 545         configurationEntity.setConfigType("JSON");
 546         configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
 547         configurationEntity.setDescription("test");
 548         entity.setConfigurationData(configurationEntity);
 549         policyData.add(entity);
 550         PolicyManagerServlet servlet = new PolicyManagerServlet();
 551         PolicyController controller = mock(PolicyController.class);
 552         List<String> list = new ArrayList<>();
 553         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
 554                 + " onlyFolders: false}}");
 555         for (int i = 0; i < list.size(); i++) {
 556             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 557             try {
 558                 when(request.getReader()).thenReturn(reader);
 559                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 560                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 561                         null)).thenReturn(policyData);
 562                 servlet.setPolicyController(controller);
 563                 servlet.setTestUserId("Test");
 564                 servlet.doPost(request, response);
 565             } catch (Exception e1) {
 566                 logger.error("Exception Occured" + e1);
 567                 fail();
 568             }
 569         }
 570     }
 571
 572     @SuppressWarnings("static-access")
 573     @Test
 574     public void editActionPolicyTest() {
 575         List<Object> policyData = new ArrayList<>();
 576         String policyContent = "";
 577         String configData = "";
 578         try {
 579             ClassLoader classLoader = getClass().getClassLoader();
 580             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
 581             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
 582         } catch (Exception e1) {
 583             logger.error("Exception Occured" + e1);
 584         }
 585         PolicyEntity entity = new PolicyEntity();
 586         entity.setPolicyName("Action_TestActionPolicy.1.xml");
 587         entity.setPolicyData(policyContent);
 588         entity.setScope("com");
 589         ActionBodyEntity configurationEntity = new ActionBodyEntity();
 590         configurationEntity.setActionBody(configData);
 591         configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
 592         entity.setActionBodyEntity(configurationEntity);
 593         policyData.add(entity);
 594         PolicyManagerServlet servlet = new PolicyManagerServlet();
 595         PolicyController controller = mock(PolicyController.class);
 596         List<String> list = new ArrayList<>();
 597         list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
 598         for (int i = 0; i < list.size(); i++) {
 599             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 600             try {
 601                 when(request.getReader()).thenReturn(reader);
 602                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 603                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 604                         null)).thenReturn(policyData);
 605                 servlet.setPolicyController(controller);
 606                 servlet.setTestUserId("Test");
 607                 servlet.doPost(request, response);
 608             } catch (Exception e1) {
 609                 logger.error("Exception Occured" + e1);
 610                 fail();
 611             }
 612         }
 613     }
 614
 615     @SuppressWarnings("static-access")
 616     @Test
 617     public void editDecisionPolicyTest() {
 618         List<Object> policyData = new ArrayList<>();
 619         String policyContent = "";
 620         try {
 621             ClassLoader classLoader = getClass().getClassLoader();
 622             policyContent = IOUtils
 623                     .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
 624         } catch (Exception e1) {
 625             logger.error("Exception Occured" + e1);
 626         }
 627         PolicyEntity entity = new PolicyEntity();
 628         entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
 629         entity.setPolicyData(policyContent);
 630         entity.setScope("com");
 631         policyData.add(entity);
 632         PolicyManagerServlet servlet = new PolicyManagerServlet();
 633         PolicyController controller = mock(PolicyController.class);
 634         List<String> list = new ArrayList<>();
 635         list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
 636                 + " onlyFolders: false}}");
 637         for (int i = 0; i < list.size(); i++) {
 638             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 639             try {
 640                 when(request.getReader()).thenReturn(reader);
 641                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 642                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 643                         null)).thenReturn(policyData);
 644                 servlet.setPolicyController(controller);
 645                 servlet.setTestUserId("Test");
 646                 servlet.doPost(request, response);
 647             } catch (Exception e1) {
 648                 logger.error("Exception Occured" + e1);
 649                 fail();
 650             }
 651         }
 652     }
 653
 654     @Test
 655     public void testAddScope() {
 656         PolicyManagerServlet servlet = new PolicyManagerServlet();
 657         PolicyController controller = mock(PolicyController.class);
 658         List<BufferedReader> readers = new ArrayList<>();
 659         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
 660         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
 661         readers.add(new BufferedReader(
 662                 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
 663         for (int i = 0; i < readers.size(); i++) {
 664             try {
 665                 when(request.getReader()).thenReturn(readers.get(i));
 666                 PolicyManagerServlet.setPolicyController(controller);
 667                 servlet.doPost(request, response);
 668                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 669             } catch (Exception e1) {
 670                 logger.error("Exception Occured" + e1);
 671                 fail();
 672             }
 673         }
 674     }
 675
 676     @Test
 677     public void testClone() {
 678         PolicyManagerServlet servlet = new PolicyManagerServlet();
 679         PolicyController controller = mock(PolicyController.class);
 680         List<BufferedReader> readers = new ArrayList<>();
 681         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
 682                 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 683         when(controller.getDataByQuery(
 684                 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
 685                         .thenReturn(basePolicyData);
 686         readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
 687                 + " newPath: 'com.Config_testClone.1.xml'}}")));
 688         for (int i = 0; i < readers.size(); i++) {
 689             try {
 690                 when(request.getReader()).thenReturn(readers.get(i));
 691                 PolicyManagerServlet.setPolicyController(controller);
 692                 servlet.doPost(request, response);
 693                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 694             } catch (Exception e1) {
 695                 logger.error("Exception Occured" + e1);
 696                 fail();
 697             }
 698         }
 699     }
 700
 701     @Test
 702     public void testRename() {
 703         PolicyManagerServlet servlet = new PolicyManagerServlet();
 704         PolicyController controller = mock(PolicyController.class);
 705         List<BufferedReader> readers = new ArrayList<>();
 706         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
 707                 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 708         when(controller.getDataByQuery(
 709                 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
 710                         .thenReturn(basePolicyData);
 711         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
 712                 + " newPath: 'com.Config_testClone.1.xml'}}")));
 713         for (int i = 0; i < readers.size(); i++) {
 714             try {
 715                 when(request.getReader()).thenReturn(readers.get(i));
 716                 PolicyManagerServlet.setPolicyController(controller);
 717                 servlet.doPost(request, response);
 718                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 719             } catch (Exception e1) {
 720                 logger.error("Exception Occured" + e1);
 721                 fail();
 722             }
 723         }
 724     }
 725
 726     @Test
 727     public void testRenameScope() {
 728         PolicyManagerServlet servlet = new PolicyManagerServlet();
 729         PolicyController controller = mock(PolicyController.class);
 730         List<BufferedReader> readers = new ArrayList<>();
 731         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
 732         for (int i = 0; i < readers.size(); i++) {
 733             try {
 734                 when(request.getReader()).thenReturn(readers.get(i));
 735                 PolicyManagerServlet.setPolicyController(controller);
 736                 servlet.doPost(request, response);
 737                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 738             } catch (Exception e1) {
 739                 logger.error("Exception Occured" + e1);
 740                 fail();
 741             }
 742         }
 743     }
 744 }