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.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         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                 commonClassDao = mock(CommonClassDao.class);
 144
 145         }
 146
 147         @Test
 148         public void testInit(){
 149                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 150                 ServletConfig servletConfig = mock(ServletConfig.class);
 151         try {
 152                 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 153                 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 154                 System.setProperty("xacml.rest.admin.closedLoopJSON", new File(".").getCanonicalPath() + File.separator + "src"+ File.separator + "test" + File.separator + "resources" + File.separator + "JSONConfig.json");
 155                         servlet.init(servletConfig);
 156
 157                         assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
 158                         assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
 159
 160                 } catch (Exception e1) {
 161                         logger.error("Exception Occured"+e1);
 162                         fail();
 163                 }
 164         }
 165
 166         @Test
 167         public void testBadInitJson() {
 168                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 169                 ServletConfig servletConfig = mock(ServletConfig.class);
 170         try {
 171                 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 172                 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 173                 System.setProperty("xacml.rest.admin.closedLoopJSON", new File(".").getCanonicalPath() + File.separator + "src"+ File.separator + "test" + File.separator + "resources" + File.separator + "JSONConfig.foo");
 174                         servlet.init(servletConfig);
 175                 } catch (Exception e1) {
 176                         logger.error("Exception Occured"+e1);
 177                         fail();
 178                 }
 179         }
 180
 181         @Test
 182         public void testBadInitJsonInvalidFile() {
 183                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 184                 ServletConfig servletConfig = mock(ServletConfig.class);
 185         try {
 186                 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 187                 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 188                 System.setProperty("xacml.rest.admin.closedLoopJSON", new File(".").getCanonicalPath() + File.separator + "src"+ File.separator + "test" + File.separator + "resources" + File.separator + "IDonotExist.json");
 189                         servlet.init(servletConfig);
 190                 } catch (Exception e1) {
 191                         logger.error("Exception Occured"+e1);
 192                         fail();
 193                 }
 194         }
 195
 196         @SuppressWarnings("static-access")
 197         @Test
 198         public void testDescribePolicy(){
 199                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 200         PolicyController controller = mock(PolicyController.class);
 201         BufferedReader reader = new BufferedReader(new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
 202         try {
 203                         when(request.getReader()).thenReturn(reader);
 204                         String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
 205                         when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
 206                         servlet.setPolicyController(controller);
 207                         servlet.doPost(request, response);
 208                 } catch (Exception e1) {
 209                         logger.error("Exception Occured"+e1);
 210                         fail();
 211                 }
 212         }
 213
 214
 215         @SuppressWarnings("static-access")
 216         @Test
 217         public void testPolicyScopeList(){
 218                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 219         PolicyController controller = mock(PolicyController.class);
 220         List<String> list = new ArrayList<>();
 221         list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
 222         list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
 223         for(int i =0; i < list.size(); i++){
 224                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 225             try {
 226                         when(request.getReader()).thenReturn(reader);
 227                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 228                         when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
 229                         when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null)).thenReturn(policyEditorScopes);
 230                         when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null)).thenReturn(policyVersion);
 231                         servlet.setPolicyController(controller);
 232                         servlet.setTestUserId("Test");
 233                         servlet.doPost(request, response);
 234                 } catch (Exception e1) {
 235                         logger.error("Exception Occured"+e1);
 236                         fail();
 237                 }
 238         }
 239         }
 240
 241         @SuppressWarnings("static-access")
 242         @Test
 243         public void editBasePolicyTest(){
 244                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 245         PolicyController controller = mock(PolicyController.class);
 246         List<String> list = new ArrayList<>();
 247         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
 248         for(int i =0; i < list.size(); i++){
 249                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 250             try {
 251                         when(request.getReader()).thenReturn(reader);
 252                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 253                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(basePolicyData);
 254                         servlet.setPolicyController(controller);
 255                         servlet.setTestUserId("Test");
 256                         servlet.doPost(request, response);
 257                 } catch (Exception e1) {
 258                         logger.error("Exception Occured"+e1);
 259                         fail();
 260                 }
 261         }
 262         }
 263
 264         @SuppressWarnings("static-access")
 265         @Test
 266         public void editBRMSParamPolicyTest(){
 267                 List<Object> policyData = new ArrayList<>();
 268         String policyContent = "";
 269         String configData = "";
 270         try {
 271                         ClassLoader classLoader = getClass().getClassLoader();
 272                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 273                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
 274                 } catch (Exception e1) {
 275                         logger.error("Exception Occured"+e1);
 276                 }
 277         PolicyEntity entity = new PolicyEntity();
 278         entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 279         entity.setPolicyData(policyContent);
 280         entity.setScope("com");
 281         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 282         configurationEntity.setConfigBody(configData);
 283         configurationEntity.setConfigType("OTHER");
 284         configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
 285         configurationEntity.setDescription("test");
 286         entity.setConfigurationData(configurationEntity);
 287         policyData.add(entity);
 288                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 289         PolicyController controller = mock(PolicyController.class);
 290         List<String> list = new ArrayList<>();
 291         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml', onlyFolders: false}}");
 292         for(int i =0; i < list.size(); i++){
 293                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 294             try {
 295                         when(request.getReader()).thenReturn(reader);
 296                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 297                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 298                         servlet.setPolicyController(controller);
 299                         servlet.setTestUserId("Test");
 300                         servlet.doPost(request, response);
 301                 } catch (Exception e1) {
 302                         logger.error("Exception Occured"+e1);
 303                         fail();
 304                 }
 305         }
 306         }
 307
 308         @SuppressWarnings("static-access")
 309         @Test
 310         public void editBRMSRawPolicyTest(){
 311                 List<Object> policyData = new ArrayList<>();
 312         String policyContent = "";
 313         String configData = "";
 314         try {
 315                         ClassLoader classLoader = getClass().getClassLoader();
 316                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
 317                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
 318                 } catch (Exception e1) {
 319                         logger.error("Exception Occured"+e1);
 320                 }
 321         PolicyEntity entity = new PolicyEntity();
 322         entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
 323         entity.setPolicyData(policyContent);
 324         entity.setScope("com");
 325         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 326         configurationEntity.setConfigBody(configData);
 327         configurationEntity.setConfigType("OTHER");
 328         configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
 329         configurationEntity.setDescription("test");
 330         entity.setConfigurationData(configurationEntity);
 331         policyData.add(entity);
 332                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 333         PolicyController controller = mock(PolicyController.class);
 334         List<String> list = new ArrayList<>();
 335         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml', onlyFolders: false}}");
 336         for(int i =0; i < list.size(); i++){
 337                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 338             try {
 339                         when(request.getReader()).thenReturn(reader);
 340                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 341                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 342                         servlet.setPolicyController(controller);
 343                         servlet.setTestUserId("Test");
 344                         servlet.doPost(request, response);
 345                 } catch (Exception e1) {
 346                         logger.error("Exception Occured"+e1);
 347                         fail();
 348                 }
 349         }
 350         }
 351
 352         @SuppressWarnings("static-access")
 353         @Test
 354         public void editClosedLoopFaultPolicyTest(){
 355                 List<Object> policyData = new ArrayList<>();
 356         String policyContent = "";
 357         String configData = "";
 358         try {
 359                         ClassLoader classLoader = getClass().getClassLoader();
 360                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
 361                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
 362                 } catch (Exception e1) {
 363                         logger.error("Exception Occured"+e1);
 364                 }
 365         PolicyEntity entity = new PolicyEntity();
 366         entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
 367         entity.setPolicyData(policyContent);
 368         entity.setScope("com");
 369         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 370         configurationEntity.setConfigBody(configData);
 371         configurationEntity.setConfigType("JSON");
 372         configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
 373         configurationEntity.setDescription("test");
 374         entity.setConfigurationData(configurationEntity);
 375         policyData.add(entity);
 376                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 377         PolicyController controller = mock(PolicyController.class);
 378         List<String> list = new ArrayList<>();
 379         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml', onlyFolders: false}}");
 380         for(int i =0; i < list.size(); i++){
 381                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 382             try {
 383                         when(request.getReader()).thenReturn(reader);
 384                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 385                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 386                         servlet.setPolicyController(controller);
 387                         servlet.setTestUserId("Test");
 388                         servlet.doPost(request, response);
 389                 } catch (Exception e1) {
 390                         logger.error("Exception Occured"+e1);
 391                         fail();
 392                 }
 393         }
 394         }
 395
 396         @SuppressWarnings("static-access")
 397         @Test
 398         public void editClosedLoopPMPolicyTest(){
 399                 List<Object> policyData = new ArrayList<>();
 400         String policyContent = "";
 401         String configData = "";
 402         try {
 403                         ClassLoader classLoader = getClass().getClassLoader();
 404                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
 405                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
 406                 } catch (Exception e1) {
 407                         logger.error("Exception Occured"+e1);
 408                 }
 409         PolicyEntity entity = new PolicyEntity();
 410         entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
 411         entity.setPolicyData(policyContent);
 412         entity.setScope("com");
 413         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 414         configurationEntity.setConfigBody(configData);
 415         configurationEntity.setConfigType("JSON");
 416         configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
 417         configurationEntity.setDescription("test");
 418         entity.setConfigurationData(configurationEntity);
 419         policyData.add(entity);
 420                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 421         PolicyController controller = mock(PolicyController.class);
 422         List<String> list = new ArrayList<>();
 423         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml', onlyFolders: false}}");
 424         for(int i =0; i < list.size(); i++){
 425                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 426             try {
 427                         when(request.getReader()).thenReturn(reader);
 428                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 429                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 430                         servlet.setPolicyController(controller);
 431                         servlet.setTestUserId("Test");
 432                         servlet.doPost(request, response);
 433                 } catch (Exception e1) {
 434                         logger.error("Exception Occured"+e1);
 435                         fail();
 436                 }
 437         }
 438         }
 439
 440         @SuppressWarnings("static-access")
 441         @Test
 442         public void editMicroServicePolicyTest(){
 443                 GroupPolicyScopeList groupData = new  GroupPolicyScopeList();
 444                 groupData.setGroupName("Test");
 445                 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,closedLoopControlName=SampleClosedLoop");
 446                 List<Object> groupListData = new ArrayList<>();
 447                 groupListData.add(groupData);
 448                 commonClassDao = mock(CommonClassDao.class);
 449                 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
 450                 List<Object> policyData = new ArrayList<>();
 451         String policyContent = "";
 452         String configData = "";
 453         try {
 454                         ClassLoader classLoader = getClass().getClassLoader();
 455                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
 456                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
 457                 } catch (Exception e1) {
 458                         logger.error("Exception Occured"+e1);
 459                 }
 460         PolicyEntity entity = new PolicyEntity();
 461         entity.setPolicyName("Config_MS_vFirewall.1.xml");
 462         entity.setPolicyData(policyContent);
 463         entity.setScope("com");
 464         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 465         configurationEntity.setConfigBody(configData);
 466         configurationEntity.setConfigType("JSON");
 467         configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
 468         configurationEntity.setDescription("test");
 469         entity.setConfigurationData(configurationEntity);
 470         policyData.add(entity);
 471                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 472         PolicyController controller = mock(PolicyController.class);
 473         List<String> list = new ArrayList<>();
 474         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
 475         for(int i =0; i < list.size(); i++){
 476                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 477             try {
 478                         when(request.getReader()).thenReturn(reader);
 479                         when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList", "resource=SampleResource,service=SampleService,type=SampleType,closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
 480                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 481                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 482                         servlet.setPolicyController(controller);
 483                         servlet.setTestUserId("Test");
 484                         servlet.doPost(request, response);
 485                 } catch (Exception e1) {
 486                         logger.error("Exception Occured"+e1);
 487                         fail();
 488                 }
 489         }
 490         }
 491
 492         @SuppressWarnings("static-access")
 493         @Test
 494         public void editFirewallPolicyTest(){
 495                 List<Object> policyData = new ArrayList<>();
 496         String policyContent = "";
 497         String configData = "";
 498         try {
 499                         ClassLoader classLoader = getClass().getClassLoader();
 500                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
 501                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
 502                 } catch (Exception e1) {
 503                         logger.error("Exception Occured"+e1);
 504                 }
 505         PolicyEntity entity = new PolicyEntity();
 506         entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
 507         entity.setPolicyData(policyContent);
 508         entity.setScope("com");
 509         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 510         configurationEntity.setConfigBody(configData);
 511         configurationEntity.setConfigType("JSON");
 512         configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
 513         configurationEntity.setDescription("test");
 514         entity.setConfigurationData(configurationEntity);
 515         policyData.add(entity);
 516                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 517         PolicyController controller = mock(PolicyController.class);
 518         List<String> list = new ArrayList<>();
 519         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml', onlyFolders: false}}");
 520         for(int i =0; i < list.size(); i++){
 521                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 522             try {
 523                         when(request.getReader()).thenReturn(reader);
 524                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 525                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 526                         servlet.setPolicyController(controller);
 527                         servlet.setTestUserId("Test");
 528                         servlet.doPost(request, response);
 529                 } catch (Exception e1) {
 530                         logger.error("Exception Occured"+e1);
 531                         fail();
 532                 }
 533         }
 534         }
 535
 536         @SuppressWarnings("static-access")
 537         @Test
 538         public void editActionPolicyTest(){
 539                 List<Object> policyData = new ArrayList<>();
 540         String policyContent = "";
 541         String configData = "";
 542         try {
 543                         ClassLoader classLoader = getClass().getClassLoader();
 544                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
 545                         configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
 546                 } catch (Exception e1) {
 547                         logger.error("Exception Occured"+e1);
 548                 }
 549         PolicyEntity entity = new PolicyEntity();
 550         entity.setPolicyName("Action_TestActionPolicy.1.xml");
 551         entity.setPolicyData(policyContent);
 552         entity.setScope("com");
 553         ActionBodyEntity configurationEntity = new ActionBodyEntity();
 554         configurationEntity.setActionBody(configData);
 555         configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
 556         entity.setActionBodyEntity(configurationEntity);
 557         policyData.add(entity);
 558                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 559         PolicyController controller = mock(PolicyController.class);
 560         List<String> list = new ArrayList<>();
 561         list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml', onlyFolders: false}}");
 562         for(int i =0; i < list.size(); i++){
 563                 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 564             try {
 565                         when(request.getReader()).thenReturn(reader);
 566                         when(controller.getRoles("Test")).thenReturn(rolesdata);
 567                         when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null)).thenReturn(policyData);
 568                         servlet.setPolicyController(controller);
 569                         servlet.setTestUserId("Test");
 570                         servlet.doPost(request, response);
 571                 } catch (Exception e1) {
 572                         logger.error("Exception Occured"+e1);
 573                         fail();
 574                 }
 575         }
 576         }
 577
 578         @SuppressWarnings("static-access")
 579         @Test
 580         public void editDecisionPolicyTest(){
 581                 List<Object> policyData = new ArrayList<>();
 582         String policyContent = "";
 583         try {
 584                         ClassLoader classLoader = getClass().getClassLoader();
 585                         policyContent = IOUtils.toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
 586                 } catch (Exception e1) {
 587                         logger.error("Exception Occured"+e1);
 588                 }
 589         PolicyEntity entity = new PolicyEntity();
 590         entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
 591         entity.setPolicyData(policyContent);
 592         entity.setScope("com");
 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/Decision_TestDecisionPolicyWithRuleAlgorithms.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", null)).thenReturn(policyData);
 604                         servlet.setPolicyController(controller);
 605                         servlet.setTestUserId("Test");
 606                         servlet.doPost(request, response);
 607                 } catch (Exception e1) {
 608                         logger.error("Exception Occured"+e1);
 609                         fail();
 610                 }
 611         }
 612         }
 613
 614         @Test
 615         public void testAddScope(){
 616                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 617         PolicyController controller = mock(PolicyController.class);
 618         List<BufferedReader> readers = new ArrayList<>();
 619         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
 620         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
 621         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
 622         for(int i=0; i<readers.size(); i++){
 623                 try {
 624                         when(request.getReader()).thenReturn(readers.get(i));
 625                         PolicyManagerServlet.setPolicyController(controller);
 626                         servlet.doPost(request, response);
 627                         assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 628                 } catch (Exception e1) {
 629                         logger.error("Exception Occured"+e1);
 630                         fail();
 631                 }
 632         }
 633         }
 634
 635         @Test
 636         public void testClone(){
 637                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 638         PolicyController controller = mock(PolicyController.class);
 639         List<BufferedReader> readers = new ArrayList<>();
 640         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName", "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 641                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null)).thenReturn(basePolicyData);
 642         readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml', newPath: 'com.Config_testClone.1.xml'}}")));
 643         for(int i=0; i<readers.size(); i++){
 644                 try {
 645                         when(request.getReader()).thenReturn(readers.get(i));
 646                         PolicyManagerServlet.setPolicyController(controller);
 647                         servlet.doPost(request, response);
 648                         assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 649                 } catch (Exception e1) {
 650                         logger.error("Exception Occured"+e1);
 651                         fail();
 652                 }
 653         }
 654         }
 655
 656         @Test
 657         public void testRename(){
 658                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 659         PolicyController controller = mock(PolicyController.class);
 660         List<BufferedReader> readers = new ArrayList<>();
 661         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName", "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 662                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null)).thenReturn(basePolicyData);
 663         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml', newPath: 'com.Config_testClone.1.xml'}}")));
 664         for(int i=0; i<readers.size(); i++){
 665                 try {
 666                         when(request.getReader()).thenReturn(readers.get(i));
 667                         PolicyManagerServlet.setPolicyController(controller);
 668                         servlet.doPost(request, response);
 669                         assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 670                 } catch (Exception e1) {
 671                         logger.error("Exception Occured"+e1);
 672                         fail();
 673                 }
 674         }
 675         }
 676
 677         @Test
 678         public void testRenameScope(){
 679                 PolicyManagerServlet servlet = new PolicyManagerServlet();
 680         PolicyController controller = mock(PolicyController.class);
 681         List<BufferedReader> readers = new ArrayList<>();
 682         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
 683         for(int i=0; i<readers.size(); i++){
 684                 try {
 685                         when(request.getReader()).thenReturn(readers.get(i));
 686                         PolicyManagerServlet.setPolicyController(controller);
 687                         servlet.doPost(request, response);
 688                         assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 689                 } catch (Exception e1) {
 690                         logger.error("Exception Occured"+e1);
 691                         fail();
 692                 }
 693         }
 694         }
 695 }