2 * ============LICENSE_START=======================================================
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
13 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
23 package org.onap.policy.admin;
25 import static org.junit.Assert.assertEquals;
26 import static org.junit.Assert.assertTrue;
27 import static org.junit.Assert.fail;
29 import java.io.BufferedReader;
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;
68 @RunWith(PowerMockRunner.class)
69 public class PolicyManagerServletTest extends Mockito {
71 private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
72 private List<String> headers = new ArrayList<String>();
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;
86 * @throws Exception should not get one
89 public void setUp() throws Exception {
90 logger.info("setUp: Entering");
92 request = mock(HttpServletRequest.class);
93 response = new MockHttpServletResponse();
95 PolicyController.setjUnit(true);
96 UserInfo userinfo = new UserInfo();
97 userinfo.setUserLoginId("Test");
98 userinfo.setUserName("Test");
100 rolesdata = new ArrayList<>();
101 Roles roles = new Roles();
102 roles.setLoginId("Test");
103 roles.setRole("super-admin");
104 Roles roles1 = new Roles();
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);
115 basePolicyData = new ArrayList<>();
116 String policyContent = "";
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);
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);
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);
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);
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);
168 public void testInit() {
169 PolicyManagerServlet servlet = new PolicyManagerServlet();
170 ServletConfig servletConfig = mock(ServletConfig.class);
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);
179 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
180 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
182 } catch (Exception e1) {
183 logger.error("Exception Occured" + e1);
189 public void testBadInitJson() {
190 PolicyManagerServlet servlet = new PolicyManagerServlet();
191 ServletConfig servletConfig = mock(ServletConfig.class);
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);
206 public void testBadInitJsonInvalidFile() {
207 PolicyManagerServlet servlet = new PolicyManagerServlet();
208 ServletConfig servletConfig = mock(ServletConfig.class);
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);
222 @SuppressWarnings("static-access")
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'}}"));
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);
241 @SuppressWarnings("static-access")
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)));
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);
269 @SuppressWarnings("static-access")
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)));
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);
293 @SuppressWarnings("static-access")
295 public void editBRMSParamPolicyTest() {
296 List<Object> policyData = new ArrayList<>();
297 String policyContent = "";
298 String configData = "";
300 ClassLoader classLoader = getClass().getClassLoader();
302 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
304 .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
305 } catch (Exception e1) {
306 logger.error("Exception Occured" + e1);
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)));
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);
341 @SuppressWarnings("static-access")
343 public void editBRMSRawPolicyTest() {
344 List<Object> policyData = new ArrayList<>();
345 String policyContent = "";
346 String configData = "";
348 ClassLoader classLoader = getClass().getClassLoader();
350 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
352 IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
353 } catch (Exception e1) {
354 logger.error("Exception Occured" + e1);
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)));
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);
389 @SuppressWarnings("static-access")
391 public void editClosedLoopFaultPolicyTest() {
392 List<Object> policyData = new ArrayList<>();
393 String policyContent = "";
394 String configData = "";
396 ClassLoader classLoader = getClass().getClassLoader();
398 IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
400 IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
401 } catch (Exception e1) {
402 logger.error("Exception Occured" + e1);
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)));
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);
437 @SuppressWarnings("static-access")
439 public void editClosedLoopPMPolicyTest() {
440 List<Object> policyData = new ArrayList<>();
441 String policyContent = "";
442 String configData = "";
444 ClassLoader classLoader = getClass().getClassLoader();
445 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
447 IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
448 } catch (Exception e1) {
449 logger.error("Exception Occured" + e1);
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)));
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);
484 @SuppressWarnings("static-access")
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 = "";
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);
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)));
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);
540 @SuppressWarnings("static-access")
542 public void editFirewallPolicyTest() {
543 List<Object> policyData = new ArrayList<>();
544 String policyContent = "";
545 String configData = "";
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);
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)));
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);
586 @SuppressWarnings("static-access")
588 public void editActionPolicyTest() {
589 List<Object> policyData = new ArrayList<>();
590 String policyContent = "";
591 String configData = "";
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);
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)));
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);
629 @SuppressWarnings("static-access")
631 public void editDecisionPolicyTest() {
632 List<Object> policyData = new ArrayList<>();
633 String policyContent = "";
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);
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)));
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);
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++) {
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);
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++) {
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);
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++) {
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);
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++) {
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);
760 public void testSetPolicyNames() {
761 JsonArray mockJsonArray = Mockito.mock(JsonArray.class);
762 PolicyManagerServlet.setPolicyNames(mockJsonArray);
763 assertEquals(mockJsonArray, PolicyManagerServlet.getPolicyNames());
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();
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);
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();
787 servlet.doPost(mockRequest, mockResponse);
788 verify(mockRequest).getReader();
789 verify(mockResponse).getWriter();
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);
799 doThrow(IOException.class).when(mockRequest).getReader();
800 when(mockResponse.getWriter()).thenReturn(mockPrintWriter);
802 servlet.doPost(null, mockResponse);
803 verify(mockResponse).getWriter();
806 @PrepareForTest(ServletFileUpload.class)
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));