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;
30 import java.io.BufferedReader;
32 import java.io.IOException;
33 import java.io.InputStream;
34 import java.io.OutputStream;
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.io.IOUtils;
51 import org.json.JSONArray;
52 import org.json.JSONObject;
53 import org.junit.Before;
54 import org.junit.FixMethodOrder;
55 import org.junit.Test;
56 import org.junit.runners.MethodSorters;
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.powermock.reflect.Whitebox;
75 import org.springframework.mock.web.MockHttpServletResponse;
77 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
78 public class PolicyManagerServletTest extends Mockito {
80 private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
81 private List<String> headers = new ArrayList<String>();
83 private static List<Object> rolesdata;
84 private static List<Object> basePolicyData;
85 private static List<Object> policyEditorScopes;
86 private static List<Object> policyVersion;
87 private static CommonClassDao commonClassDao;
88 private ConfigurationDataEntity configurationEntity;
89 private HttpServletRequest request;
90 private MockHttpServletResponse response;
95 * @throws Exception should not get one
98 public void setUp() throws Exception {
99 logger.info("setUp: Entering");
101 request = mock(HttpServletRequest.class);
102 response = new MockHttpServletResponse();
104 PolicyController.setjUnit(true);
105 UserInfo userinfo = new UserInfo();
106 userinfo.setUserLoginId("Test");
107 userinfo.setUserName("Test");
109 rolesdata = new ArrayList<>();
110 Roles roles = new Roles();
111 roles.setLoginId("Test");
112 roles.setRole("super-admin");
113 Roles roles1 = new Roles();
115 roles1.setName("Test");
116 assertTrue("Test".equals(roles1.getName()));
117 roles1.setLoginId("Test");
118 roles1.setRole("admin");
119 roles1.setScope("['com','Test']");
120 rolesdata.add(roles);
121 rolesdata.add(roles1);
124 basePolicyData = new ArrayList<>();
125 String policyContent = "";
127 ClassLoader classLoader = getClass().getClassLoader();
128 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
129 } catch (Exception e1) {
130 logger.error("Exception Occured" + e1);
132 PolicyEntity entity = new PolicyEntity();
133 entity.setPolicyName("Config_SampleTest.1.xml");
134 entity.setPolicyData(policyContent);
135 entity.setScope("com");
136 configurationEntity = new ConfigurationDataEntity();
137 configurationEntity.setConfigBody("Sample Test");
138 configurationEntity.setConfigType("OTHER");
139 configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
140 configurationEntity.setDescription("test");
141 entity.setConfigurationData(configurationEntity);
142 basePolicyData.add(entity);
144 // PolicyEditorScopes data
145 policyEditorScopes = new ArrayList<>();
146 PolicyEditorScopes scopes = new PolicyEditorScopes();
147 scopes.setScopeName("com");
148 scopes.setUserCreatedBy(userinfo);
149 scopes.setUserModifiedBy(userinfo);
150 PolicyEditorScopes scopes1 = new PolicyEditorScopes();
151 scopes1.setScopeName("com\\Test");
152 scopes1.setUserCreatedBy(userinfo);
153 scopes1.setUserModifiedBy(userinfo);
154 policyEditorScopes.add(scopes);
155 policyEditorScopes.add(scopes1);
157 // PolicyVersion data
158 policyVersion = new ArrayList<>();
159 PolicyVersion policy = new PolicyVersion();
160 policy.setPolicyName("com\\Config_SampleTest1206");
161 policy.setActiveVersion(1);
162 policy.setHigherVersion(1);
163 policy.setCreatedBy("Test");
164 policy.setModifiedBy("Test");
165 policyVersion.add(policy);
167 HttpSession mockSession = mock(HttpSession.class);
168 User user = new User();
169 user.setOrgUserId("Test");
170 Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
171 Mockito.when(request.getSession(false)).thenReturn(mockSession);
172 commonClassDao = mock(CommonClassDao.class);
177 public void test01Init() {
178 PolicyManagerServlet servlet = new PolicyManagerServlet();
179 ServletConfig servletConfig = mock(ServletConfig.class);
181 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
182 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
183 System.setProperty("xacml.rest.admin.closedLoopJSON",
184 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
185 + "resources" + File.separator + "JSONConfig.json");
186 servlet.init(servletConfig);
188 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
189 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
191 } catch (Exception e1) {
192 logger.error("Exception Occured" + e1);
198 public void test02BadInitJson() {
199 PolicyManagerServlet servlet = new PolicyManagerServlet();
200 ServletConfig servletConfig = mock(ServletConfig.class);
202 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
203 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
204 System.setProperty("xacml.rest.admin.closedLoopJSON",
205 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
206 + "resources" + File.separator + "JSONConfig.foo");
207 servlet.init(servletConfig);
208 } catch (Exception e1) {
209 logger.error("Exception Occured" + e1);
215 public void test03BadInitJsonInvalidFile() {
216 PolicyManagerServlet servlet = new PolicyManagerServlet();
217 ServletConfig servletConfig = mock(ServletConfig.class);
219 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
220 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
221 System.setProperty("xacml.rest.admin.closedLoopJSON",
222 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
223 + "resources" + File.separator + "IDonotExist.json");
224 servlet.init(servletConfig);
225 } catch (Exception e1) {
226 logger.error("Exception Occured" + e1);
231 @SuppressWarnings("static-access")
233 public void test04DescribePolicy() {
234 PolicyManagerServlet servlet = new PolicyManagerServlet();
235 PolicyController controller = mock(PolicyController.class);
236 BufferedReader reader = new BufferedReader(
237 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
239 when(request.getReader()).thenReturn(reader);
240 String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
241 when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
242 servlet.setPolicyController(controller);
243 servlet.doPost(request, response);
244 } catch (Exception e1) {
245 logger.error("Exception Occured" + e1);
250 @SuppressWarnings("static-access")
252 public void test05PolicyScopeList() {
253 PolicyManagerServlet servlet = new PolicyManagerServlet();
254 PolicyController controller = mock(PolicyController.class);
255 List<String> list = new ArrayList<>();
256 list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
257 list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
258 for (int i = 0; i < list.size(); i++) {
259 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
261 when(request.getReader()).thenReturn(reader);
262 when(controller.getRoles("Test")).thenReturn(rolesdata);
263 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
264 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
265 .thenReturn(policyEditorScopes);
266 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
267 .thenReturn(policyVersion);
268 servlet.setPolicyController(controller);
269 servlet.setTestUserId("Test");
270 servlet.doPost(request, response);
271 } catch (Exception e1) {
272 logger.error("Exception Occured" + e1);
278 @SuppressWarnings("static-access")
280 public void test06editBasePolicyTest() {
281 PolicyManagerServlet servlet = new PolicyManagerServlet();
282 PolicyController controller = mock(PolicyController.class);
283 List<String> list = new ArrayList<>();
284 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
285 for (int i = 0; i < list.size(); i++) {
286 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
288 when(request.getReader()).thenReturn(reader);
289 when(controller.getRoles("Test")).thenReturn(rolesdata);
290 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
291 null)).thenReturn(basePolicyData);
292 servlet.setPolicyController(controller);
293 servlet.setTestUserId("Test");
294 servlet.doPost(request, response);
295 } catch (Exception e1) {
296 logger.error("Exception Occured" + e1);
302 @SuppressWarnings("static-access")
304 public void test07editBRMSParamPolicyTest() {
305 List<Object> policyData = new ArrayList<>();
306 String policyContent = "";
307 String configData = "";
309 ClassLoader classLoader = getClass().getClassLoader();
311 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
313 .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
314 } catch (Exception e1) {
315 logger.error("Exception Occured" + e1);
317 PolicyEntity entity = new PolicyEntity();
318 entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
319 entity.setPolicyData(policyContent);
320 entity.setScope("com");
321 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
322 configurationEntity.setConfigBody(configData);
323 configurationEntity.setConfigType("OTHER");
324 configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
325 configurationEntity.setDescription("test");
326 entity.setConfigurationData(configurationEntity);
327 policyData.add(entity);
328 PolicyManagerServlet servlet = new PolicyManagerServlet();
329 PolicyController controller = mock(PolicyController.class);
330 List<String> list = new ArrayList<>();
331 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
332 + " onlyFolders: false}}");
333 for (int i = 0; i < list.size(); i++) {
334 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
336 when(request.getReader()).thenReturn(reader);
337 when(controller.getRoles("Test")).thenReturn(rolesdata);
338 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
339 null)).thenReturn(policyData);
340 servlet.setPolicyController(controller);
341 servlet.setTestUserId("Test");
342 servlet.doPost(request, response);
343 } catch (Exception e1) {
344 logger.error("Exception Occured" + e1);
350 @SuppressWarnings("static-access")
352 public void test08editBRMSRawPolicyTest() {
353 List<Object> policyData = new ArrayList<>();
354 String policyContent = "";
355 String configData = "";
357 ClassLoader classLoader = getClass().getClassLoader();
359 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
361 IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
362 } catch (Exception e1) {
363 logger.error("Exception Occured" + e1);
365 PolicyEntity entity = new PolicyEntity();
366 entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
367 entity.setPolicyData(policyContent);
368 entity.setScope("com");
369 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
370 configurationEntity.setConfigBody(configData);
371 configurationEntity.setConfigType("OTHER");
372 configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
373 configurationEntity.setDescription("test");
374 entity.setConfigurationData(configurationEntity);
375 policyData.add(entity);
376 PolicyManagerServlet servlet = new PolicyManagerServlet();
377 PolicyController controller = mock(PolicyController.class);
378 List<String> list = new ArrayList<>();
379 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
380 + " onlyFolders: false}}");
381 for (int i = 0; i < list.size(); i++) {
382 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
384 when(request.getReader()).thenReturn(reader);
385 when(controller.getRoles("Test")).thenReturn(rolesdata);
386 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
387 null)).thenReturn(policyData);
388 servlet.setPolicyController(controller);
389 servlet.setTestUserId("Test");
390 servlet.doPost(request, response);
391 } catch (Exception e1) {
392 logger.error("Exception Occured" + e1);
398 @SuppressWarnings("static-access")
400 public void test09editClosedLoopFaultPolicyTest() {
401 List<Object> policyData = new ArrayList<>();
402 String policyContent = "";
403 String configData = "";
405 ClassLoader classLoader = getClass().getClassLoader();
407 IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
409 IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
410 } catch (Exception e1) {
411 logger.error("Exception Occured" + e1);
413 PolicyEntity entity = new PolicyEntity();
414 entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
415 entity.setPolicyData(policyContent);
416 entity.setScope("com");
417 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
418 configurationEntity.setConfigBody(configData);
419 configurationEntity.setConfigType("JSON");
420 configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
421 configurationEntity.setDescription("test");
422 entity.setConfigurationData(configurationEntity);
423 policyData.add(entity);
424 PolicyManagerServlet servlet = new PolicyManagerServlet();
425 PolicyController controller = mock(PolicyController.class);
426 List<String> list = new ArrayList<>();
427 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
428 + " onlyFolders: false}}");
429 for (int i = 0; i < list.size(); i++) {
430 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
432 when(request.getReader()).thenReturn(reader);
433 when(controller.getRoles("Test")).thenReturn(rolesdata);
434 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
435 null)).thenReturn(policyData);
436 servlet.setPolicyController(controller);
437 servlet.setTestUserId("Test");
438 servlet.doPost(request, response);
439 } catch (Exception e1) {
440 logger.error("Exception Occured" + e1);
446 @SuppressWarnings("static-access")
448 public void test10editClosedLoopPMPolicyTest() {
449 List<Object> policyData = new ArrayList<>();
450 String policyContent = "";
451 String configData = "";
453 ClassLoader classLoader = getClass().getClassLoader();
454 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
456 IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
457 } catch (Exception e1) {
458 logger.error("Exception Occured" + e1);
460 PolicyEntity entity = new PolicyEntity();
461 entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
462 entity.setPolicyData(policyContent);
463 entity.setScope("com");
464 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
465 configurationEntity.setConfigBody(configData);
466 configurationEntity.setConfigType("JSON");
467 configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
468 configurationEntity.setDescription("test");
469 entity.setConfigurationData(configurationEntity);
470 policyData.add(entity);
471 PolicyManagerServlet servlet = new PolicyManagerServlet();
472 PolicyController controller = mock(PolicyController.class);
473 List<String> list = new ArrayList<>();
474 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
475 + " onlyFolders: false}}");
476 for (int i = 0; i < list.size(); i++) {
477 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
479 when(request.getReader()).thenReturn(reader);
480 when(controller.getRoles("Test")).thenReturn(rolesdata);
481 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
482 null)).thenReturn(policyData);
483 servlet.setPolicyController(controller);
484 servlet.setTestUserId("Test");
485 servlet.doPost(request, response);
486 } catch (Exception e1) {
487 logger.error("Exception Occured" + e1);
493 @SuppressWarnings("static-access")
495 public void test11editMicroServicePolicyTest() {
496 GroupPolicyScopeList groupData = new GroupPolicyScopeList();
497 groupData.setGroupName("Test");
498 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
499 + "closedLoopControlName=SampleClosedLoop");
500 List<Object> groupListData = new ArrayList<>();
501 groupListData.add(groupData);
502 commonClassDao = mock(CommonClassDao.class);
503 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
504 List<Object> policyData = new ArrayList<>();
505 String policyContent = "";
506 String configData = "";
508 ClassLoader classLoader = getClass().getClassLoader();
509 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
510 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
511 } catch (Exception e1) {
512 logger.error("Exception Occured" + e1);
514 PolicyEntity entity = new PolicyEntity();
515 entity.setPolicyName("Config_MS_vFirewall.1.xml");
516 entity.setPolicyData(policyContent);
517 entity.setScope("com");
518 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
519 configurationEntity.setConfigBody(configData);
520 configurationEntity.setConfigType("JSON");
521 configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
522 configurationEntity.setDescription("test");
523 entity.setConfigurationData(configurationEntity);
524 policyData.add(entity);
525 PolicyManagerServlet servlet = new PolicyManagerServlet();
526 PolicyController controller = mock(PolicyController.class);
527 List<String> list = new ArrayList<>();
528 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
529 for (int i = 0; i < list.size(); i++) {
530 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
532 when(request.getReader()).thenReturn(reader);
533 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
534 "resource=SampleResource,service=SampleService,type=SampleType,"
535 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
536 when(controller.getRoles("Test")).thenReturn(rolesdata);
537 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
538 null)).thenReturn(policyData);
539 servlet.setPolicyController(controller);
540 servlet.setTestUserId("Test");
541 servlet.doPost(request, response);
542 } catch (Exception e1) {
543 logger.error("Exception Occured" + e1);
549 @SuppressWarnings("static-access")
551 public void test12editFirewallPolicyTest() {
552 List<Object> policyData = new ArrayList<>();
553 String policyContent = "";
554 String configData = "";
556 ClassLoader classLoader = getClass().getClassLoader();
557 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
558 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
559 } catch (Exception e1) {
560 logger.error("Exception Occured" + e1);
562 PolicyEntity entity = new PolicyEntity();
563 entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
564 entity.setPolicyData(policyContent);
565 entity.setScope("com");
566 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
567 configurationEntity.setConfigBody(configData);
568 configurationEntity.setConfigType("JSON");
569 configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
570 configurationEntity.setDescription("test");
571 entity.setConfigurationData(configurationEntity);
572 policyData.add(entity);
573 PolicyManagerServlet servlet = new PolicyManagerServlet();
574 PolicyController controller = mock(PolicyController.class);
575 List<String> list = new ArrayList<>();
576 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
577 + " onlyFolders: false}}");
578 for (int i = 0; i < list.size(); i++) {
579 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
581 when(request.getReader()).thenReturn(reader);
582 when(controller.getRoles("Test")).thenReturn(rolesdata);
583 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
584 null)).thenReturn(policyData);
585 servlet.setPolicyController(controller);
586 servlet.setTestUserId("Test");
587 servlet.doPost(request, response);
588 } catch (Exception e1) {
589 logger.error("Exception Occured" + e1);
595 @SuppressWarnings("static-access")
597 public void test13editActionPolicyTest() {
598 List<Object> policyData = new ArrayList<>();
599 String policyContent = "";
600 String configData = "";
602 ClassLoader classLoader = getClass().getClassLoader();
603 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
604 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
605 } catch (Exception e1) {
606 logger.error("Exception Occured" + e1);
608 PolicyEntity entity = new PolicyEntity();
609 entity.setPolicyName("Action_TestActionPolicy.1.xml");
610 entity.setPolicyData(policyContent);
611 entity.setScope("com");
612 ActionBodyEntity configurationEntity = new ActionBodyEntity();
613 configurationEntity.setActionBody(configData);
614 configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
615 entity.setActionBodyEntity(configurationEntity);
616 policyData.add(entity);
617 PolicyManagerServlet servlet = new PolicyManagerServlet();
618 PolicyController controller = mock(PolicyController.class);
619 List<String> list = new ArrayList<>();
620 list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
621 for (int i = 0; i < list.size(); i++) {
622 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
624 when(request.getReader()).thenReturn(reader);
625 when(controller.getRoles("Test")).thenReturn(rolesdata);
626 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
627 null)).thenReturn(policyData);
628 servlet.setPolicyController(controller);
629 servlet.setTestUserId("Test");
630 servlet.doPost(request, response);
631 } catch (Exception e1) {
632 logger.error("Exception Occured" + e1);
638 @SuppressWarnings("static-access")
640 public void test14editDecisionPolicyTest() {
641 List<Object> policyData = new ArrayList<>();
642 String policyContent = "";
644 ClassLoader classLoader = getClass().getClassLoader();
645 policyContent = IOUtils
646 .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
647 } catch (Exception e1) {
648 logger.error("Exception Occured" + e1);
650 PolicyEntity entity = new PolicyEntity();
651 entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
652 entity.setPolicyData(policyContent);
653 entity.setScope("com");
654 policyData.add(entity);
655 PolicyManagerServlet servlet = new PolicyManagerServlet();
656 PolicyController controller = mock(PolicyController.class);
657 List<String> list = new ArrayList<>();
658 list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
659 + " onlyFolders: false}}");
660 for (int i = 0; i < list.size(); i++) {
661 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
663 when(request.getReader()).thenReturn(reader);
664 when(controller.getRoles("Test")).thenReturn(rolesdata);
665 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
666 null)).thenReturn(policyData);
667 servlet.setPolicyController(controller);
668 servlet.setTestUserId("Test");
669 servlet.doPost(request, response);
670 } catch (Exception e1) {
671 logger.error("Exception Occured" + e1);
678 public void test15AddScope() {
679 PolicyManagerServlet servlet = new PolicyManagerServlet();
680 PolicyController controller = mock(PolicyController.class);
681 List<BufferedReader> readers = new ArrayList<>();
682 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
683 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
684 readers.add(new BufferedReader(
685 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
686 for (int i = 0; i < readers.size(); i++) {
688 when(request.getReader()).thenReturn(readers.get(i));
689 PolicyManagerServlet.setPolicyController(controller);
690 servlet.doPost(request, response);
691 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
692 } catch (Exception e1) {
693 logger.error("Exception Occured" + e1);
700 public void test16Clone() {
701 PolicyManagerServlet servlet = new PolicyManagerServlet();
702 PolicyController controller = mock(PolicyController.class);
703 List<BufferedReader> readers = new ArrayList<>();
704 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
705 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
706 when(controller.getDataByQuery(
707 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
708 .thenReturn(basePolicyData);
709 readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
710 + " newPath: 'com.Config_testClone.1.xml'}}")));
711 for (int i = 0; i < readers.size(); i++) {
713 when(request.getReader()).thenReturn(readers.get(i));
714 PolicyManagerServlet.setPolicyController(controller);
715 servlet.doPost(request, response);
716 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
717 } catch (Exception e1) {
718 logger.error("Exception Occured" + e1);
725 public void test17Rename() {
726 PolicyManagerServlet servlet = new PolicyManagerServlet();
727 PolicyController controller = mock(PolicyController.class);
728 List<BufferedReader> readers = new ArrayList<>();
729 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
730 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
731 when(controller.getDataByQuery(
732 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
733 .thenReturn(basePolicyData);
734 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
735 + " newPath: 'com.Config_testClone.1.xml'}}")));
736 for (int i = 0; i < readers.size(); i++) {
738 when(request.getReader()).thenReturn(readers.get(i));
739 PolicyManagerServlet.setPolicyController(controller);
740 servlet.doPost(request, response);
741 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
742 } catch (Exception e1) {
743 logger.error("Exception Occured" + e1);
750 public void test18RenameScope() throws Exception {
751 PolicyManagerServlet servlet = new PolicyManagerServlet();
752 PolicyController controller = mock(PolicyController.class);
753 List<BufferedReader> readers = new ArrayList<>();
754 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
755 for (int i = 0; i < readers.size(); i++) {
757 when(request.getReader()).thenReturn(readers.get(i));
758 PolicyManagerServlet.setPolicyController(controller);
759 servlet.doPost(request, response);
760 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
761 } catch (Exception e1) {
762 logger.error("Exception Occured" + e1);
767 String inScopeName = "\\\\\\\\inScopeName";
768 String newScopeName = "\\\\\\\\newScopeName";
769 List<Object> scopesList = new ArrayList<Object>();
770 PolicyEditorScopes mockPolicyEditorScope = Mockito.mock(PolicyEditorScopes.class);
771 scopesList.add(mockPolicyEditorScope);
772 when(mockPolicyEditorScope.getScopeName()).thenReturn("inScopeName");
773 Whitebox.invokeMethod(servlet, "renameScope", scopesList, inScopeName, newScopeName, controller);
774 verify(mockPolicyEditorScope, atLeast(1)).getScopeName();
778 public void test19SetPolicyNames() {
779 JsonArray mockJsonArray = Mockito.mock(JsonArray.class);
780 PolicyManagerServlet.setPolicyNames(mockJsonArray);
781 assertEquals(mockJsonArray, PolicyManagerServlet.getPolicyNames());
785 public void test20DoPostSetErrorException() throws IOException {
786 PolicyManagerServlet servlet = new PolicyManagerServlet();
787 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
788 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
789 doThrow(IOException.class).when(mockRequest).getReader();
790 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
791 servlet.doPost(mockRequest, mockResponse);
792 verify(mockRequest).getReader();
796 public void test21DoPostException() throws IOException {
797 PolicyManagerServlet servlet = new PolicyManagerServlet();
798 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
799 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
801 doThrow(IOException.class).when(mockRequest).getReader();
802 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
803 doThrow(IOException.class).when(mockResponse).getWriter();
805 servlet.doPost(mockRequest, mockResponse);
806 verify(mockRequest).getReader();
807 verify(mockResponse).getWriter();
811 public void test22DoPostSuccess() throws IOException {
812 PolicyManagerServlet servlet = new PolicyManagerServlet();
813 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
814 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
815 PrintWriter mockPrintWriter = Mockito.mock(PrintWriter.class);
817 doThrow(IOException.class).when(mockRequest).getReader();
818 when(mockResponse.getWriter()).thenReturn(mockPrintWriter);
820 servlet.doPost(null, mockResponse);
821 verify(mockResponse).getWriter();
825 public void test23DoPostUploadFileException() {
826 PolicyManagerServlet servlet = new PolicyManagerServlet() {
827 private static final long serialVersionUID = 1L;
829 protected boolean isMultipartContent(HttpServletRequest request) {
833 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
834 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
835 servlet.doPost(mockRequest, mockResponse);
839 public void test24ProcessFormFile() throws Exception {
840 long fileSizeLimit = 10;
842 PolicyManagerServlet servlet = new PolicyManagerServlet() {
843 private static final long serialVersionUID = 1L;
846 protected long getFileSizeLimit() {
847 return fileSizeLimit;
851 protected long copyStream(InputStream inputStream, OutputStream outputStream) throws IOException {
852 // don't really copy the file
856 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
857 HttpServletResponse mockResp = Mockito.mock(HttpServletResponse.class);
858 FileItem mockFileItem = Mockito.mock(FileItem.class);
859 InputStream mockInputStream = Mockito.mock(InputStream.class);
861 when(mockFileItem.getName()).thenReturn("testFileName.xls");
862 when(mockFileItem.getInputStream()).thenReturn(mockInputStream);
863 when(mockFileItem.getSize()).thenReturn(fileSizeLimit + 1);
865 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem, mockResp);
866 verify(mockFileItem, atLeast(1)).getName();
867 verify(mockFileItem, atLeast(1)).getSize();
869 when(mockFileItem.getName()).thenReturn("testFileName.txt");
870 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem, mockResp);
871 verify(mockFileItem, atLeast(1)).getName();
873 when(mockFileItem.getSize()).thenReturn(fileSizeLimit);
874 when(mockFileItem.getName()).thenReturn("testFileName.xls");
875 when(mockFileItem.getInputStream()).thenThrow(IOException.class);
876 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem, mockResp);
877 verify(mockFileItem, atLeast(1)).getName();
878 verify(mockFileItem, atLeast(1)).getInputStream();
879 verify(mockFileItem, atLeast(1)).getSize();
883 public void test25SearchPolicyList() throws Exception {
884 PolicyManagerServlet servlet = new PolicyManagerServlet();
885 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
886 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
888 mockJSONObject.append("policyList", "sampleValue");
890 Object res = Whitebox.invokeMethod(servlet, "searchPolicyList", mockJSONObject, mockRequest);
891 assert (res instanceof JSONObject);
892 assertNotNull(((JSONObject) res).get("result"));
896 public void test26LookupPolicyData() throws Exception {
897 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
898 User mockUser = Mockito.mock(User.class);
899 UserInfo mockUserInfo = Mockito.mock(UserInfo.class);
900 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
901 List<JSONObject> resultList = new ArrayList<>();
902 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
903 resultList.add(mockJSONObject);
905 Date mockDate = Mockito.mock(Date.class);
906 List<Object> policyDataList = new ArrayList<>();
907 PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
908 policyDataList.add(mockPolicyVersion);
909 JSONArray mockJSONArray = Mockito.mock(JSONArray.class);
911 List<Object> rolesList = new ArrayList<>();
912 Roles adminRole = Mockito.mock(Roles.class);
913 Roles editorRole = Mockito.mock(Roles.class);
914 Roles guestRole = Mockito.mock(Roles.class);
915 adminRole.setRole("admin");
916 editorRole.setRole("editor");
917 guestRole.setRole("guest");
919 List<Object> filterDataList = new ArrayList<>();
920 PolicyVersion mockPolicyVersionFilter = Mockito.mock(PolicyVersion.class);
921 filterDataList.add(mockPolicyVersionFilter);
922 List<String> listOfRoles = new ArrayList<String>();
923 Set<String> setOfScopes = new HashSet<String>();
924 Pair<Set<String>, List<String>> pairList = new Pair<Set<String>, List<String>>(setOfScopes, listOfRoles);
926 PolicyManagerServlet servlet = new PolicyManagerServlet() {
927 private static final long serialVersionUID = 1L;
930 protected User getUserSession(HttpServletRequest request) {
935 protected Pair<Set<String>, List<String>> checkRoleAndScope(List<Object> userRoles) {
940 PolicyManagerServlet.setPolicyController(mockPolicyController);
941 when(mockPolicyController.getRoles(any(String.class))).thenReturn(rolesList);
942 when(mockPolicyController.getData(any(Class.class))).thenReturn(filterDataList);
943 when(mockPolicyVersion.getPolicyName()).thenReturn("sampleName");
944 when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
945 when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
946 when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
947 when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
948 when(mockPolicyController.getEntityItem(UserInfo.class, "userLoginId", "sampleUserName"))
949 .thenReturn(mockUserInfo);
950 when(mockUserInfo.getUserName()).thenReturn("testUserName");
952 Whitebox.invokeMethod(servlet, "getPolicyControllerInstance");
954 boolean result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
955 mockPolicyController, resultList);
958 verify(mockPolicyController, atLeast(1)).getRoles(any());
959 verify(mockPolicyController, atLeast(1)).getRoles(any());
960 verify(mockPolicyController, atLeast(1)).getData(any());
961 verify(mockPolicyController, atLeast(1)).getEntityItem(UserInfo.class, "userLoginId", "sampleUserName");
962 verify(mockPolicyVersion, atLeast(1)).getPolicyName();
963 verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
964 verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
965 verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
966 verify(mockPolicyVersion, atLeast(1)).getModifiedBy();
967 verify(mockUserInfo, atLeast(1)).getUserName();
969 when(mockPolicyVersionFilter.getPolicyName()).thenReturn("testAdminScope" + File.separator);
970 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
971 mockPolicyController, resultList);
973 verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
975 setOfScopes.add("testAdminScope");
976 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
977 mockPolicyController, resultList);
979 verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
981 listOfRoles.add("super-admin");
982 listOfRoles.add("super-editor");
983 listOfRoles.add("super-guest");
984 filterDataList.clear();
986 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
987 mockPolicyController, resultList);
989 verify(mockPolicyController, atLeast(1)).getData(any(Class.class));
992 listOfRoles.add("admin");
993 listOfRoles.add("editor");
994 listOfRoles.add("guest");
996 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
997 mockPolicyController, resultList);
1000 setOfScopes.add("testScope");
1001 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, mockJSONArray,
1002 mockPolicyController, resultList);
1007 public void test27DeleteEntityFromEsAndPolicyEntityTable() throws Exception {
1008 PolicyManagerServlet servlet = new PolicyManagerServlet();
1009 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1010 PolicyRestController mockPolicyRestController = Mockito.mock(PolicyRestController.class);
1011 PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
1012 ConfigurationDataEntity mockConfigDataEntity = Mockito.mock(ConfigurationDataEntity.class);
1013 ActionBodyEntity mockActionBodyEntity = Mockito.mock(ActionBodyEntity.class);
1015 String policyNamewithoutExtension = "Config_";
1016 String configName = "";
1017 String actionBodyName = "";
1019 when(mockPolicyEntity.getScope()).thenReturn("");
1020 when(mockPolicyEntity.getPolicyName()).thenReturn("");
1021 Mockito.doNothing().when(mockPolicyRestController).deleteElasticData(any(String.class));
1022 Mockito.doNothing().when(mockPolicyController).deleteData(mockPolicyEntity);
1023 when(mockPolicyEntity.getConfigurationData()).thenReturn(mockConfigDataEntity);
1024 when(mockPolicyEntity.getActionBodyEntity()).thenReturn(mockActionBodyEntity);
1025 when(mockConfigDataEntity.getConfigurationName()).thenReturn(configName);
1026 when(mockActionBodyEntity.getActionBodyName()).thenReturn(actionBodyName);
1027 when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, configName)).thenReturn("");
1029 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1030 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1032 verify(mockPolicyEntity, atLeast(1)).getScope();
1033 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1034 verify(mockPolicyEntity, atLeast(1)).getConfigurationData();
1035 verify(mockConfigDataEntity, atLeast(1)).getConfigurationName();
1037 policyNamewithoutExtension = "Action_";
1038 when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, actionBodyName))
1041 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1042 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1044 verify(mockPolicyEntity, atLeast(1)).getScope();
1045 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1046 verify(mockPolicyEntity, atLeast(1)).getActionBodyEntity();
1047 verify(mockActionBodyEntity, atLeast(1)).getActionBodyName();
1049 policyNamewithoutExtension = "Other_";
1050 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1051 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1053 verify(mockPolicyEntity, atLeast(1)).getScope();
1054 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1055 verify(mockPolicyRestController, atLeast(1)).deleteElasticData(any(String.class));
1056 verify(mockPolicyController, atLeast(1)).deleteData(mockPolicyEntity);
1060 public void test28Delete() throws Exception {
1061 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
1062 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
1063 User mockUser = Mockito.mock(User.class);
1064 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1065 List<Object> policyEntityList = new ArrayList<Object>();
1066 PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
1067 policyEntityList.add(mockPolicyEntity);
1070 PolicyManagerServlet servlet = new PolicyManagerServlet() {
1071 private static final long serialVersionUID = 1L;
1074 protected User getUserSession(HttpServletRequest request) {
1079 PolicyManagerServlet.setPolicyController(mockPolicyController);
1080 when(mockUser.getOrgUserId()).thenReturn("sampleUserId");
1081 when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.1.xml");
1082 when(mockJSONObject.has("deleteVersion")).thenReturn(true);
1083 when(mockJSONObject.getString("deleteVersion")).thenReturn("ALL");
1084 when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1085 .thenReturn(policyEntityList);
1086 when(mockPolicyEntity.getPolicyId()).thenReturn(policyId);
1087 when(mockPolicyEntity.getScope()).thenReturn("sampleScope");
1088 when(mockPolicyEntity.getPolicyName()).thenReturn("samplePolicyName");
1090 JSONObject returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1091 assertTrue(returnObj.has("result"));
1092 verify(mockUser, atLeast(1)).getOrgUserId();
1093 verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1094 verify(mockJSONObject, atLeast(1)).has(any(String.class));
1095 verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1096 verify(mockPolicyEntity, atLeast(1)).getPolicyId();
1097 verify(mockPolicyEntity, atLeast(1)).getScope();
1098 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1100 when(mockJSONObject.getString("path")).thenReturn("/sampleScope\\:samplePolicyName.1.xml");
1101 when(mockJSONObject.getString("deleteVersion")).thenReturn("CURRENT");
1102 returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1103 assertTrue(returnObj.has("result"));
1104 verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1106 when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.2.txt");
1107 when(mockJSONObject.has("deleteVersion")).thenReturn(false);
1108 returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1109 assertTrue(returnObj.has("result"));
1110 verify(mockJSONObject, atLeast(1)).getString("path");
1111 verify(mockJSONObject, atLeast(1)).has("deleteVersion");
1115 public void test29ParsePolicyList() throws Exception {
1116 PolicyManagerServlet servlet = new PolicyManagerServlet();
1117 List<JSONObject> resultList = new ArrayList<JSONObject>();
1118 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1119 UserInfo mockUserInfo = Mockito.mock(UserInfo.class);
1120 String policyName = "sampleName\\";
1121 String policyVersion = "sampleVersion";
1122 List<Object> activeDataList = new ArrayList<Object>();
1123 PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
1124 activeDataList.add(mockPolicyVersion);
1125 Date mockDate = Mockito.mock(Date.class);
1127 when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1128 .thenReturn(activeDataList);
1129 when(mockPolicyVersion.getPolicyName()).thenReturn("testPolicyName");
1130 when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
1131 when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
1132 when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
1133 when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
1135 // This intermittently throws an NPE, even when fixing the method order
1137 when(mockPolicyController.getEntityItem(UserInfo.class, "userLoginId", "sampleUserName"))
1138 .thenReturn(mockUserInfo);
1139 when(mockUserInfo.getUserName()).thenReturn("testUserName");
1140 Whitebox.invokeMethod(servlet, "parsePolicyList", resultList, mockPolicyController, policyName, policyVersion);
1141 verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1142 verify(mockPolicyVersion, atLeast(1)).getPolicyName();
1143 verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
1144 verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
1145 verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
1146 verify(mockPolicyVersion, atLeast(1)).getModifiedBy();