2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2020 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.assertFalse;
27 import static org.junit.Assert.assertNotNull;
28 import static org.junit.Assert.assertTrue;
29 import static org.junit.Assert.fail;
31 import java.io.BufferedReader;
33 import java.io.IOException;
34 import java.io.InputStream;
35 import java.io.PrintWriter;
36 import java.io.StringReader;
37 import java.util.ArrayList;
38 import java.util.Collections;
39 import java.util.Date;
40 import java.util.HashSet;
41 import java.util.List;
43 import javax.json.JsonArray;
44 import javax.script.SimpleBindings;
45 import javax.servlet.ServletConfig;
46 import javax.servlet.http.HttpServletRequest;
47 import javax.servlet.http.HttpServletResponse;
48 import javax.servlet.http.HttpSession;
49 import org.apache.commons.fileupload.FileItem;
50 import org.apache.commons.fileupload.servlet.ServletFileUpload;
51 import org.apache.commons.io.IOUtils;
52 import org.json.JSONArray;
53 import org.json.JSONObject;
54 import org.junit.Before;
55 import org.junit.Test;
56 import org.junit.runner.RunWith;
57 import org.mockito.Mockito;
58 import org.onap.policy.common.logging.flexlogger.FlexLogger;
59 import org.onap.policy.common.logging.flexlogger.Logger;
60 import org.onap.policy.controller.CreateDcaeMicroServiceController;
61 import org.onap.policy.controller.PolicyController;
62 import org.onap.policy.model.Roles;
63 import org.onap.policy.rest.dao.CommonClassDao;
64 import org.onap.policy.rest.jpa.ActionBodyEntity;
65 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
66 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
67 import org.onap.policy.rest.jpa.PolicyEditorScopes;
68 import org.onap.policy.rest.jpa.PolicyEntity;
69 import org.onap.policy.rest.jpa.PolicyVersion;
70 import org.onap.policy.rest.jpa.UserInfo;
71 import org.onap.policy.utils.UserUtils.Pair;
72 import org.onap.portalsdk.core.domain.User;
73 import org.onap.portalsdk.core.util.SystemProperties;
74 import org.onap.portalsdk.core.web.support.UserUtils;
75 import org.powermock.api.mockito.PowerMockito;
76 import org.powermock.core.classloader.annotations.PowerMockIgnore;
77 import org.powermock.core.classloader.annotations.PrepareForTest;
78 import org.powermock.modules.junit4.PowerMockRunner;
79 import org.powermock.reflect.Whitebox;
80 import org.springframework.mock.web.MockHttpServletResponse;
82 @RunWith(PowerMockRunner.class)
83 @PowerMockIgnore({"com.sun.org.apache.xerces.*", "jdk.internal.reflect.*", "javax.xml.*", "org.xml.*", "org.w3c.*"})
84 public class PolicyManagerServletTest extends Mockito {
86 private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
87 private List<String> headers = new ArrayList<String>();
89 private static List<Object> rolesdata;
90 private static List<Object> basePolicyData;
91 private static List<Object> policyEditorScopes;
92 private static List<Object> policyVersion;
93 private static CommonClassDao commonClassDao;
94 private ConfigurationDataEntity configurationEntity;
95 private HttpServletRequest request;
96 private MockHttpServletResponse response;
101 * @throws Exception should not get one
104 public void setUp() throws Exception {
105 logger.info("setUp: Entering");
107 request = mock(HttpServletRequest.class);
108 response = new MockHttpServletResponse();
110 PolicyController.setjUnit(true);
111 UserInfo userinfo = new UserInfo();
112 userinfo.setUserLoginId("Test");
113 userinfo.setUserName("Test");
115 rolesdata = new ArrayList<>();
116 Roles roles = new Roles();
117 roles.setLoginId("Test");
118 roles.setRole("super-admin");
119 Roles roles1 = new Roles();
121 roles1.setName("Test");
122 assertTrue("Test".equals(roles1.getName()));
123 roles1.setLoginId("Test");
124 roles1.setRole("admin");
125 roles1.setScope("['com','Test']");
126 rolesdata.add(roles);
127 rolesdata.add(roles1);
130 basePolicyData = new ArrayList<>();
131 String policyContent = "";
133 ClassLoader classLoader = getClass().getClassLoader();
134 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
135 } catch (Exception e1) {
136 logger.error("Exception Occured" + e1);
138 PolicyEntity entity = new PolicyEntity();
139 entity.setPolicyName("Config_SampleTest.1.xml");
140 entity.setPolicyData(policyContent);
141 entity.setScope("com");
142 configurationEntity = new ConfigurationDataEntity();
143 configurationEntity.setConfigBody("Sample Test");
144 configurationEntity.setConfigType("OTHER");
145 configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
146 configurationEntity.setDescription("test");
147 entity.setConfigurationData(configurationEntity);
148 basePolicyData.add(entity);
150 // PolicyEditorScopes data
151 policyEditorScopes = new ArrayList<>();
152 PolicyEditorScopes scopes = new PolicyEditorScopes();
153 scopes.setScopeName("com");
154 scopes.setUserCreatedBy(userinfo);
155 scopes.setUserModifiedBy(userinfo);
156 PolicyEditorScopes scopes1 = new PolicyEditorScopes();
157 scopes1.setScopeName("com\\Test");
158 scopes1.setUserCreatedBy(userinfo);
159 scopes1.setUserModifiedBy(userinfo);
160 policyEditorScopes.add(scopes);
161 policyEditorScopes.add(scopes1);
163 // PolicyVersion data
164 policyVersion = new ArrayList<>();
165 PolicyVersion policy = new PolicyVersion();
166 policy.setPolicyName("com\\Config_SampleTest1206");
167 policy.setActiveVersion(1);
168 policy.setHigherVersion(1);
169 policy.setCreatedBy("Test");
170 policy.setModifiedBy("Test");
171 policyVersion.add(policy);
173 HttpSession mockSession = mock(HttpSession.class);
174 User user = new User();
175 user.setOrgUserId("Test");
176 Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
177 Mockito.when(request.getSession(false)).thenReturn(mockSession);
178 commonClassDao = mock(CommonClassDao.class);
183 public void testInit() {
184 PolicyManagerServlet servlet = new PolicyManagerServlet();
185 ServletConfig servletConfig = mock(ServletConfig.class);
187 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
188 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
189 System.setProperty("xacml.rest.admin.closedLoopJSON",
190 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
191 + "resources" + File.separator + "JSONConfig.json");
192 servlet.init(servletConfig);
194 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
195 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
197 } catch (Exception e1) {
198 logger.error("Exception Occured" + e1);
204 public void testBadInitJson() {
205 PolicyManagerServlet servlet = new PolicyManagerServlet();
206 ServletConfig servletConfig = mock(ServletConfig.class);
208 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
209 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
210 System.setProperty("xacml.rest.admin.closedLoopJSON",
211 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
212 + "resources" + File.separator + "JSONConfig.foo");
213 servlet.init(servletConfig);
214 } catch (Exception e1) {
215 logger.error("Exception Occured" + e1);
221 public void testBadInitJsonInvalidFile() {
222 PolicyManagerServlet servlet = new PolicyManagerServlet();
223 ServletConfig servletConfig = mock(ServletConfig.class);
225 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
226 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
227 System.setProperty("xacml.rest.admin.closedLoopJSON",
228 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
229 + "resources" + File.separator + "IDonotExist.json");
230 servlet.init(servletConfig);
231 } catch (Exception e1) {
232 logger.error("Exception Occured" + e1);
237 @SuppressWarnings("static-access")
239 public void testDescribePolicy() {
240 PolicyManagerServlet servlet = new PolicyManagerServlet();
241 PolicyController controller = mock(PolicyController.class);
242 BufferedReader reader = new BufferedReader(
243 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
245 when(request.getReader()).thenReturn(reader);
246 String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
247 when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
248 servlet.setPolicyController(controller);
249 servlet.doPost(request, response);
250 } catch (Exception e1) {
251 logger.error("Exception Occured" + e1);
256 @SuppressWarnings("static-access")
258 public void testPolicyScopeList() {
259 PolicyManagerServlet servlet = new PolicyManagerServlet();
260 PolicyController controller = mock(PolicyController.class);
261 List<String> list = new ArrayList<>();
262 list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
263 list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
264 for (int i = 0; i < list.size(); i++) {
265 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
267 when(request.getReader()).thenReturn(reader);
268 when(controller.getRoles("Test")).thenReturn(rolesdata);
269 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
270 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
271 .thenReturn(policyEditorScopes);
272 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
273 .thenReturn(policyVersion);
274 servlet.setPolicyController(controller);
275 servlet.setTestUserId("Test");
276 servlet.doPost(request, response);
277 } catch (Exception e1) {
278 logger.error("Exception Occured" + e1);
284 @SuppressWarnings("static-access")
286 public void editBasePolicyTest() {
287 PolicyManagerServlet servlet = new PolicyManagerServlet();
288 PolicyController controller = mock(PolicyController.class);
289 List<String> list = new ArrayList<>();
290 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
291 for (int i = 0; i < list.size(); i++) {
292 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
294 when(request.getReader()).thenReturn(reader);
295 when(controller.getRoles("Test")).thenReturn(rolesdata);
296 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
297 null)).thenReturn(basePolicyData);
298 servlet.setPolicyController(controller);
299 servlet.setTestUserId("Test");
300 servlet.doPost(request, response);
301 } catch (Exception e1) {
302 logger.error("Exception Occured" + e1);
308 @SuppressWarnings("static-access")
310 public void editBRMSParamPolicyTest() {
311 List<Object> policyData = new ArrayList<>();
312 String policyContent = "";
313 String configData = "";
315 ClassLoader classLoader = getClass().getClassLoader();
317 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
319 .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
320 } catch (Exception e1) {
321 logger.error("Exception Occured" + e1);
323 PolicyEntity entity = new PolicyEntity();
324 entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
325 entity.setPolicyData(policyContent);
326 entity.setScope("com");
327 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
328 configurationEntity.setConfigBody(configData);
329 configurationEntity.setConfigType("OTHER");
330 configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
331 configurationEntity.setDescription("test");
332 entity.setConfigurationData(configurationEntity);
333 policyData.add(entity);
334 PolicyManagerServlet servlet = new PolicyManagerServlet();
335 PolicyController controller = mock(PolicyController.class);
336 List<String> list = new ArrayList<>();
337 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
338 + " onlyFolders: false}}");
339 for (int i = 0; i < list.size(); i++) {
340 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
342 when(request.getReader()).thenReturn(reader);
343 when(controller.getRoles("Test")).thenReturn(rolesdata);
344 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
345 null)).thenReturn(policyData);
346 servlet.setPolicyController(controller);
347 servlet.setTestUserId("Test");
348 servlet.doPost(request, response);
349 } catch (Exception e1) {
350 logger.error("Exception Occured" + e1);
356 @SuppressWarnings("static-access")
358 public void editBRMSRawPolicyTest() {
359 List<Object> policyData = new ArrayList<>();
360 String policyContent = "";
361 String configData = "";
363 ClassLoader classLoader = getClass().getClassLoader();
365 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
367 IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
368 } catch (Exception e1) {
369 logger.error("Exception Occured" + e1);
371 PolicyEntity entity = new PolicyEntity();
372 entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
373 entity.setPolicyData(policyContent);
374 entity.setScope("com");
375 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
376 configurationEntity.setConfigBody(configData);
377 configurationEntity.setConfigType("OTHER");
378 configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
379 configurationEntity.setDescription("test");
380 entity.setConfigurationData(configurationEntity);
381 policyData.add(entity);
382 PolicyManagerServlet servlet = new PolicyManagerServlet();
383 PolicyController controller = mock(PolicyController.class);
384 List<String> list = new ArrayList<>();
385 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
386 + " onlyFolders: false}}");
387 for (int i = 0; i < list.size(); i++) {
388 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
390 when(request.getReader()).thenReturn(reader);
391 when(controller.getRoles("Test")).thenReturn(rolesdata);
392 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
393 null)).thenReturn(policyData);
394 servlet.setPolicyController(controller);
395 servlet.setTestUserId("Test");
396 servlet.doPost(request, response);
397 } catch (Exception e1) {
398 logger.error("Exception Occured" + e1);
404 @SuppressWarnings("static-access")
406 public void editClosedLoopFaultPolicyTest() {
407 List<Object> policyData = new ArrayList<>();
408 String policyContent = "";
409 String configData = "";
411 ClassLoader classLoader = getClass().getClassLoader();
413 IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
415 IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
416 } catch (Exception e1) {
417 logger.error("Exception Occured" + e1);
419 PolicyEntity entity = new PolicyEntity();
420 entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
421 entity.setPolicyData(policyContent);
422 entity.setScope("com");
423 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
424 configurationEntity.setConfigBody(configData);
425 configurationEntity.setConfigType("JSON");
426 configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
427 configurationEntity.setDescription("test");
428 entity.setConfigurationData(configurationEntity);
429 policyData.add(entity);
430 PolicyManagerServlet servlet = new PolicyManagerServlet();
431 PolicyController controller = mock(PolicyController.class);
432 List<String> list = new ArrayList<>();
433 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
434 + " onlyFolders: false}}");
435 for (int i = 0; i < list.size(); i++) {
436 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
438 when(request.getReader()).thenReturn(reader);
439 when(controller.getRoles("Test")).thenReturn(rolesdata);
440 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
441 null)).thenReturn(policyData);
442 servlet.setPolicyController(controller);
443 servlet.setTestUserId("Test");
444 servlet.doPost(request, response);
445 } catch (Exception e1) {
446 logger.error("Exception Occured" + e1);
452 @SuppressWarnings("static-access")
454 public void editClosedLoopPMPolicyTest() {
455 List<Object> policyData = new ArrayList<>();
456 String policyContent = "";
457 String configData = "";
459 ClassLoader classLoader = getClass().getClassLoader();
460 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
462 IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
463 } catch (Exception e1) {
464 logger.error("Exception Occured" + e1);
466 PolicyEntity entity = new PolicyEntity();
467 entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
468 entity.setPolicyData(policyContent);
469 entity.setScope("com");
470 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
471 configurationEntity.setConfigBody(configData);
472 configurationEntity.setConfigType("JSON");
473 configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
474 configurationEntity.setDescription("test");
475 entity.setConfigurationData(configurationEntity);
476 policyData.add(entity);
477 PolicyManagerServlet servlet = new PolicyManagerServlet();
478 PolicyController controller = mock(PolicyController.class);
479 List<String> list = new ArrayList<>();
480 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
481 + " onlyFolders: false}}");
482 for (int i = 0; i < list.size(); i++) {
483 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
485 when(request.getReader()).thenReturn(reader);
486 when(controller.getRoles("Test")).thenReturn(rolesdata);
487 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
488 null)).thenReturn(policyData);
489 servlet.setPolicyController(controller);
490 servlet.setTestUserId("Test");
491 servlet.doPost(request, response);
492 } catch (Exception e1) {
493 logger.error("Exception Occured" + e1);
499 @SuppressWarnings("static-access")
501 public void editMicroServicePolicyTest() {
502 GroupPolicyScopeList groupData = new GroupPolicyScopeList();
503 groupData.setGroupName("Test");
504 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
505 + "closedLoopControlName=SampleClosedLoop");
506 List<Object> groupListData = new ArrayList<>();
507 groupListData.add(groupData);
508 commonClassDao = mock(CommonClassDao.class);
509 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
510 List<Object> policyData = new ArrayList<>();
511 String policyContent = "";
512 String configData = "";
514 ClassLoader classLoader = getClass().getClassLoader();
515 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
516 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
517 } catch (Exception e1) {
518 logger.error("Exception Occured" + e1);
520 PolicyEntity entity = new PolicyEntity();
521 entity.setPolicyName("Config_MS_vFirewall.1.xml");
522 entity.setPolicyData(policyContent);
523 entity.setScope("com");
524 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
525 configurationEntity.setConfigBody(configData);
526 configurationEntity.setConfigType("JSON");
527 configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
528 configurationEntity.setDescription("test");
529 entity.setConfigurationData(configurationEntity);
530 policyData.add(entity);
531 PolicyManagerServlet servlet = new PolicyManagerServlet();
532 PolicyController controller = mock(PolicyController.class);
533 List<String> list = new ArrayList<>();
534 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
535 for (int i = 0; i < list.size(); i++) {
536 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
538 when(request.getReader()).thenReturn(reader);
539 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
540 "resource=SampleResource,service=SampleService,type=SampleType,"
541 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
542 when(controller.getRoles("Test")).thenReturn(rolesdata);
543 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
544 null)).thenReturn(policyData);
545 servlet.setPolicyController(controller);
546 servlet.setTestUserId("Test");
547 servlet.doPost(request, response);
548 } catch (Exception e1) {
549 logger.error("Exception Occured" + e1);
555 @SuppressWarnings("static-access")
557 public void editFirewallPolicyTest() {
558 List<Object> policyData = new ArrayList<>();
559 String policyContent = "";
560 String configData = "";
562 ClassLoader classLoader = getClass().getClassLoader();
563 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
564 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
565 } catch (Exception e1) {
566 logger.error("Exception Occured" + e1);
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)));
587 when(request.getReader()).thenReturn(reader);
588 when(controller.getRoles("Test")).thenReturn(rolesdata);
589 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
590 null)).thenReturn(policyData);
591 servlet.setPolicyController(controller);
592 servlet.setTestUserId("Test");
593 servlet.doPost(request, response);
594 } catch (Exception e1) {
595 logger.error("Exception Occured" + e1);
601 @SuppressWarnings("static-access")
603 public void editActionPolicyTest() {
604 List<Object> policyData = new ArrayList<>();
605 String policyContent = "";
606 String configData = "";
608 ClassLoader classLoader = getClass().getClassLoader();
609 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
610 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
611 } catch (Exception e1) {
612 logger.error("Exception Occured" + e1);
614 PolicyEntity entity = new PolicyEntity();
615 entity.setPolicyName("Action_TestActionPolicy.1.xml");
616 entity.setPolicyData(policyContent);
617 entity.setScope("com");
618 ActionBodyEntity configurationEntity = new ActionBodyEntity();
619 configurationEntity.setActionBody(configData);
620 configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
621 entity.setActionBodyEntity(configurationEntity);
622 policyData.add(entity);
623 PolicyManagerServlet servlet = new PolicyManagerServlet();
624 PolicyController controller = mock(PolicyController.class);
625 List<String> list = new ArrayList<>();
626 list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
627 for (int i = 0; i < list.size(); i++) {
628 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
630 when(request.getReader()).thenReturn(reader);
631 when(controller.getRoles("Test")).thenReturn(rolesdata);
632 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
633 null)).thenReturn(policyData);
634 servlet.setPolicyController(controller);
635 servlet.setTestUserId("Test");
636 servlet.doPost(request, response);
637 } catch (Exception e1) {
638 logger.error("Exception Occured" + e1);
644 @SuppressWarnings("static-access")
646 public void editDecisionPolicyTest() {
647 List<Object> policyData = new ArrayList<>();
648 String policyContent = "";
650 ClassLoader classLoader = getClass().getClassLoader();
651 policyContent = IOUtils
652 .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
653 } catch (Exception e1) {
654 logger.error("Exception Occured" + e1);
656 PolicyEntity entity = new PolicyEntity();
657 entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
658 entity.setPolicyData(policyContent);
659 entity.setScope("com");
660 policyData.add(entity);
661 PolicyManagerServlet servlet = new PolicyManagerServlet();
662 PolicyController controller = mock(PolicyController.class);
663 List<String> list = new ArrayList<>();
664 list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
665 + " onlyFolders: false}}");
666 for (int i = 0; i < list.size(); i++) {
667 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
669 when(request.getReader()).thenReturn(reader);
670 when(controller.getRoles("Test")).thenReturn(rolesdata);
671 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
672 null)).thenReturn(policyData);
673 servlet.setPolicyController(controller);
674 servlet.setTestUserId("Test");
675 servlet.doPost(request, response);
676 } catch (Exception e1) {
677 logger.error("Exception Occured" + e1);
684 public void testAddScope() {
685 PolicyManagerServlet servlet = new PolicyManagerServlet();
686 PolicyController controller = mock(PolicyController.class);
687 List<BufferedReader> readers = new ArrayList<>();
688 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
689 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
690 readers.add(new BufferedReader(
691 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
692 for (int i = 0; i < readers.size(); i++) {
694 when(request.getReader()).thenReturn(readers.get(i));
695 PolicyManagerServlet.setPolicyController(controller);
696 servlet.doPost(request, response);
697 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
698 } catch (Exception e1) {
699 logger.error("Exception Occured" + e1);
706 public void testClone() {
707 PolicyManagerServlet servlet = new PolicyManagerServlet();
708 PolicyController controller = mock(PolicyController.class);
709 List<BufferedReader> readers = new ArrayList<>();
710 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
711 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
712 when(controller.getDataByQuery(
713 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
714 .thenReturn(basePolicyData);
715 readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
716 + " newPath: 'com.Config_testClone.1.xml'}}")));
717 for (int i = 0; i < readers.size(); i++) {
719 when(request.getReader()).thenReturn(readers.get(i));
720 PolicyManagerServlet.setPolicyController(controller);
721 servlet.doPost(request, response);
722 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
723 } catch (Exception e1) {
724 logger.error("Exception Occured" + e1);
731 public void testRename() {
732 PolicyManagerServlet servlet = new PolicyManagerServlet();
733 PolicyController controller = mock(PolicyController.class);
734 List<BufferedReader> readers = new ArrayList<>();
735 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
736 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
737 when(controller.getDataByQuery(
738 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
739 .thenReturn(basePolicyData);
740 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
741 + " newPath: 'com.Config_testClone.1.xml'}}")));
742 for (int i = 0; i < readers.size(); i++) {
744 when(request.getReader()).thenReturn(readers.get(i));
745 PolicyManagerServlet.setPolicyController(controller);
746 servlet.doPost(request, response);
747 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
748 } catch (Exception e1) {
749 logger.error("Exception Occured" + e1);
756 public void testRenameScope() throws Exception {
757 PolicyManagerServlet servlet = new PolicyManagerServlet();
758 PolicyController controller = mock(PolicyController.class);
759 List<BufferedReader> readers = new ArrayList<>();
760 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
761 for (int i = 0; i < readers.size(); i++) {
763 when(request.getReader()).thenReturn(readers.get(i));
764 PolicyManagerServlet.setPolicyController(controller);
765 servlet.doPost(request, response);
766 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
767 } catch (Exception e1) {
768 logger.error("Exception Occured" + e1);
773 String inScopeName = "\\\\\\\\inScopeName";
774 String newScopeName = "\\\\\\\\newScopeName";
775 List<Object> scopesList = new ArrayList<Object>();
776 PolicyEditorScopes mockPolicyEditorScope = Mockito.mock(PolicyEditorScopes.class);
777 scopesList.add(mockPolicyEditorScope);
778 when(mockPolicyEditorScope.getScopeName()).thenReturn("inScopeName");
779 Whitebox.invokeMethod(servlet, "renameScope", scopesList, inScopeName, newScopeName, controller);
780 verify(mockPolicyEditorScope, atLeast(1)).getScopeName();
784 public void testSetPolicyNames() {
785 JsonArray mockJsonArray = Mockito.mock(JsonArray.class);
786 PolicyManagerServlet.setPolicyNames(mockJsonArray);
787 assertEquals(mockJsonArray, PolicyManagerServlet.getPolicyNames());
791 public void testDoPostSetErrorException() throws IOException {
792 PolicyManagerServlet servlet = new PolicyManagerServlet();
793 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
794 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
795 doThrow(IOException.class).when(mockRequest).getReader();
796 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
797 servlet.doPost(mockRequest, mockResponse);
798 verify(mockRequest).getReader();
802 public void testDoPostException() throws IOException {
803 PolicyManagerServlet servlet = new PolicyManagerServlet();
804 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
805 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
807 doThrow(IOException.class).when(mockRequest).getReader();
808 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
809 doThrow(IOException.class).when(mockResponse).getWriter();
811 servlet.doPost(mockRequest, mockResponse);
812 verify(mockRequest).getReader();
813 verify(mockResponse).getWriter();
817 public void testDoPostSuccess() throws IOException {
818 PolicyManagerServlet servlet = new PolicyManagerServlet();
819 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
820 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
821 PrintWriter mockPrintWriter = Mockito.mock(PrintWriter.class);
823 doThrow(IOException.class).when(mockRequest).getReader();
824 when(mockResponse.getWriter()).thenReturn(mockPrintWriter);
826 servlet.doPost(null, mockResponse);
827 verify(mockResponse).getWriter();
830 @PrepareForTest(ServletFileUpload.class)
832 public void testDoPostUploadFileException() {
833 PolicyManagerServlet servlet = new PolicyManagerServlet();
834 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
835 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
836 PowerMockito.mockStatic(ServletFileUpload.class);
837 when(ServletFileUpload.isMultipartContent(mockRequest)).thenReturn(true);
838 servlet.doPost(mockRequest, mockResponse);
841 @SuppressWarnings("unchecked")
842 @PrepareForTest({PolicyController.class, IOUtils.class})
844 public void testProcessFormFile() throws Exception {
845 PolicyManagerServlet servlet = new PolicyManagerServlet();
846 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
847 FileItem mockFileItem = Mockito.mock(FileItem.class);
848 PowerMockito.mockStatic(PolicyController.class);
849 PowerMockito.mockStatic(IOUtils.class);
850 InputStream mockInputStream = Mockito.mock(InputStream.class);
852 long fileSizeLimit = 10;
853 when(PolicyController.getFileSizeLimit()).thenReturn(fileSizeLimit);
854 when(mockFileItem.getName()).thenReturn("testFileName.xls");
855 when(mockFileItem.getInputStream()).thenReturn(mockInputStream);
856 when(mockFileItem.getSize()).thenReturn(fileSizeLimit + 1);
858 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem);
859 verify(mockFileItem, atLeast(1)).getName();
860 verify(mockFileItem, atLeast(1)).getSize();
862 when(mockFileItem.getName()).thenReturn("testFileName.txt");
863 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem);
864 verify(mockFileItem, atLeast(1)).getName();
866 when(mockFileItem.getSize()).thenReturn(fileSizeLimit);
867 when(mockFileItem.getName()).thenReturn("testFileName.xls");
868 when(mockFileItem.getInputStream()).thenThrow(IOException.class);
869 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem);
870 verify(mockFileItem, atLeast(1)).getName();
871 verify(mockFileItem, atLeast(1)).getInputStream();
872 verify(mockFileItem, atLeast(1)).getSize();
876 public void testSearchPolicyList() throws Exception {
877 PolicyManagerServlet servlet = new PolicyManagerServlet();
878 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
879 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
881 mockJSONObject.append("policyList", "sampleValue");
883 Object res = Whitebox.invokeMethod(servlet, "searchPolicyList", mockJSONObject, mockRequest);
884 assert (res instanceof JSONObject);
885 assertNotNull(((JSONObject) res).get("result"));
888 @PrepareForTest({UserUtils.class, org.onap.policy.utils.UserUtils.class})
890 public void testLookupPolicyData() throws Exception {
891 PowerMockito.mockStatic(UserUtils.class);
892 PowerMockito.mockStatic(org.onap.policy.utils.UserUtils.class);
893 PolicyManagerServlet servlet = new PolicyManagerServlet();
894 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
895 User mockUser = Mockito.mock(User.class);
896 UserInfo mockUserInfo = Mockito.mock(UserInfo.class);
897 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
898 List<JSONObject> resultList = new ArrayList<>();
899 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
900 resultList.add(mockJSONObject);
902 Date mockDate = Mockito.mock(Date.class);
903 List<Object> policyDataList = new ArrayList<>();
904 PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
905 policyDataList.add(mockPolicyVersion);
906 JSONArray mockJSONArray = Mockito.mock(JSONArray.class);
908 List<Object> rolesList = new ArrayList<>();
909 Roles adminRole = Mockito.mock(Roles.class);
910 Roles editorRole = Mockito.mock(Roles.class);
911 Roles guestRole = Mockito.mock(Roles.class);
912 adminRole.setRole("admin");
913 editorRole.setRole("editor");
914 guestRole.setRole("guest");
916 List<Object> filterDataList = new ArrayList<>();
917 PolicyVersion mockPolicyVersionFilter = Mockito.mock(PolicyVersion.class);
918 filterDataList.add(mockPolicyVersionFilter);
919 List<String> listOfRoles = new ArrayList<String>();
920 Set<String> setOfScopes = new HashSet<String>();
921 Pair<Set<String>, List<String>> pairList = new Pair<Set<String>, List<String>>(setOfScopes, listOfRoles);
923 PolicyManagerServlet.setPolicyController(mockPolicyController);
924 PowerMockito.when(UserUtils.getUserSession(mockRequest)).thenReturn(mockUser);
925 when(mockPolicyController.getRoles(any(String.class))).thenReturn(rolesList);
926 PowerMockito.when(org.onap.policy.utils.UserUtils.checkRoleAndScope(rolesList)).thenReturn(pairList);
927 when(mockPolicyController.getData(any(Class.class))).thenReturn(filterDataList);
928 when(mockPolicyVersion.getPolicyName()).thenReturn("sampleName");
929 when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
930 when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
931 when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
932 when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
933 when(mockPolicyController.getEntityItem(UserInfo.class, "userLoginId", "sampleUserName"))
934 .thenReturn(mockUserInfo);
935 when(mockUserInfo.getUserName()).thenReturn("testUserName");
937 Whitebox.invokeMethod(servlet, "getPolicyControllerInstance");
939 boolean result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
940 mockPolicyController, resultList);
943 verify(mockPolicyController, atLeast(1)).getRoles(any());
944 verify(mockPolicyController, atLeast(1)).getRoles(any());
945 verify(mockPolicyController, atLeast(1)).getData(any());
946 verify(mockPolicyController, atLeast(1)).getEntityItem(UserInfo.class, "userLoginId", "sampleUserName");
947 verify(mockPolicyVersion, atLeast(1)).getPolicyName();
948 verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
949 verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
950 verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
951 verify(mockPolicyVersion, atLeast(1)).getModifiedBy();
952 verify(mockUserInfo, atLeast(1)).getUserName();
954 when(mockPolicyVersionFilter.getPolicyName()).thenReturn("testAdminScope" + File.separator);
955 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
956 mockPolicyController, resultList);
958 verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
960 setOfScopes.add("testAdminScope");
961 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
962 mockPolicyController, resultList);
964 verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
966 listOfRoles.add("super-admin");
967 listOfRoles.add("super-editor");
968 listOfRoles.add("super-guest");
969 filterDataList.clear();
971 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
972 mockPolicyController, resultList);
974 verify(mockPolicyController, atLeast(1)).getData(any(Class.class));
977 listOfRoles.add("admin");
978 listOfRoles.add("editor");
979 listOfRoles.add("guest");
981 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
982 mockPolicyController, resultList);
985 setOfScopes.add("testScope");
986 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, mockJSONArray,
987 mockPolicyController, resultList);
992 public void testDeleteEntityFromEsAndPolicyEntityTable() throws Exception {
993 PolicyManagerServlet servlet = new PolicyManagerServlet();
994 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
995 PolicyRestController mockPolicyRestController = Mockito.mock(PolicyRestController.class);
996 PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
997 ConfigurationDataEntity mockConfigDataEntity = Mockito.mock(ConfigurationDataEntity.class);
998 ActionBodyEntity mockActionBodyEntity = Mockito.mock(ActionBodyEntity.class);
1000 String policyNamewithoutExtension = "Config_";
1001 String configName = "";
1002 String actionBodyName = "";
1004 when(mockPolicyEntity.getScope()).thenReturn("");
1005 when(mockPolicyEntity.getPolicyName()).thenReturn("");
1006 Mockito.doNothing().when(mockPolicyRestController).deleteElasticData(any(String.class));
1007 Mockito.doNothing().when(mockPolicyController).deleteData(mockPolicyEntity);
1008 when(mockPolicyEntity.getConfigurationData()).thenReturn(mockConfigDataEntity);
1009 when(mockPolicyEntity.getActionBodyEntity()).thenReturn(mockActionBodyEntity);
1010 when(mockConfigDataEntity.getConfigurationName()).thenReturn(configName);
1011 when(mockActionBodyEntity.getActionBodyName()).thenReturn(actionBodyName);
1012 when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, configName)).thenReturn("");
1014 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1015 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1017 verify(mockPolicyEntity, atLeast(1)).getScope();
1018 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1019 verify(mockPolicyEntity, atLeast(1)).getConfigurationData();
1020 verify(mockConfigDataEntity, atLeast(1)).getConfigurationName();
1022 policyNamewithoutExtension = "Action_";
1023 when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, actionBodyName))
1026 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1027 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1029 verify(mockPolicyEntity, atLeast(1)).getScope();
1030 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1031 verify(mockPolicyEntity, atLeast(1)).getActionBodyEntity();
1032 verify(mockActionBodyEntity, atLeast(1)).getActionBodyName();
1034 policyNamewithoutExtension = "Other_";
1035 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1036 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1038 verify(mockPolicyEntity, atLeast(1)).getScope();
1039 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1040 verify(mockPolicyRestController, atLeast(1)).deleteElasticData(any(String.class));
1041 verify(mockPolicyController, atLeast(1)).deleteData(mockPolicyEntity);
1044 @PrepareForTest(UserUtils.class)
1046 public void testDelete() throws Exception {
1047 PolicyManagerServlet servlet = new PolicyManagerServlet();
1048 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
1049 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
1050 User mockUser = Mockito.mock(User.class);
1051 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1052 PowerMockito.mockStatic(UserUtils.class);
1053 List<Object> policyEntityList = new ArrayList<Object>();
1054 PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
1055 policyEntityList.add(mockPolicyEntity);
1058 PowerMockito.when(UserUtils.getUserSession(mockRequest)).thenReturn(mockUser);
1059 PolicyManagerServlet.setPolicyController(mockPolicyController);
1060 when(mockUser.getOrgUserId()).thenReturn("sampleUserId");
1061 when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.1.xml");
1062 when(mockJSONObject.has("deleteVersion")).thenReturn(true);
1063 when(mockJSONObject.getString("deleteVersion")).thenReturn("ALL");
1064 when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1065 .thenReturn(policyEntityList);
1066 when(mockPolicyEntity.getPolicyId()).thenReturn(policyId);
1067 when(mockPolicyEntity.getScope()).thenReturn("sampleScope");
1068 when(mockPolicyEntity.getPolicyName()).thenReturn("samplePolicyName");
1070 JSONObject returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1071 assertTrue(returnObj.has("result"));
1072 verify(mockUser, atLeast(1)).getOrgUserId();
1073 verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1074 verify(mockJSONObject, atLeast(1)).has(any(String.class));
1075 verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1076 verify(mockPolicyEntity, atLeast(1)).getPolicyId();
1077 verify(mockPolicyEntity, atLeast(1)).getScope();
1078 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1080 when(mockJSONObject.getString("path")).thenReturn("/sampleScope\\:samplePolicyName.1.xml");
1081 when(mockJSONObject.getString("deleteVersion")).thenReturn("CURRENT");
1082 returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1083 assertTrue(returnObj.has("result"));
1084 verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1086 when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.2.txt");
1087 when(mockJSONObject.has("deleteVersion")).thenReturn(false);
1088 returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1089 assertTrue(returnObj.has("result"));
1090 verify(mockJSONObject, atLeast(1)).getString("path");
1091 verify(mockJSONObject, atLeast(1)).has("deleteVersion");
1095 public void testParsePolicyList() throws Exception {
1096 PolicyManagerServlet servlet = new PolicyManagerServlet();
1097 List<JSONObject> resultList = new ArrayList<JSONObject>();
1098 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1099 String policyName = "sampleName\\";
1100 String policyVersion = "sampleVersion";
1101 List<Object> activeDataList = new ArrayList<Object>();
1102 PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
1103 activeDataList.add(mockPolicyVersion);
1104 Date mockDate = Mockito.mock(Date.class);
1106 when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1107 .thenReturn(activeDataList);
1108 when(mockPolicyVersion.getPolicyName()).thenReturn("testPolicyName");
1109 when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
1110 when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
1111 when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
1112 when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
1113 Whitebox.invokeMethod(servlet, "parsePolicyList", resultList, mockPolicyController, policyName, policyVersion);
1114 verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1115 verify(mockPolicyVersion, atLeast(1)).getPolicyName();
1116 verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
1117 verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
1118 verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
1119 verify(mockPolicyVersion, atLeast(1)).getModifiedBy();