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