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

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