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

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