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.OutputStream;
36 import java.io.PrintWriter;
37 import java.io.StringReader;
38 import java.util.ArrayList;
39 import java.util.Collections;
40 import java.util.Date;
41 import java.util.HashSet;
42 import java.util.List;
44 import javax.json.JsonArray;
45 import javax.script.SimpleBindings;
46 import javax.servlet.ServletConfig;
47 import javax.servlet.http.HttpServletRequest;
48 import javax.servlet.http.HttpServletResponse;
49 import javax.servlet.http.HttpSession;
50 import org.apache.commons.fileupload.FileItem;
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.FixMethodOrder;
56 import org.junit.Test;
57 import org.junit.runners.MethodSorters;
58 import org.mockito.Mockito;
59 import org.onap.policy.common.logging.flexlogger.FlexLogger;
60 import org.onap.policy.common.logging.flexlogger.Logger;
61 import org.onap.policy.controller.CreateDcaeMicroServiceController;
62 import org.onap.policy.controller.PolicyController;
63 import org.onap.policy.model.Roles;
64 import org.onap.policy.rest.dao.CommonClassDao;
65 import org.onap.policy.rest.jpa.ActionBodyEntity;
66 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
67 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
68 import org.onap.policy.rest.jpa.PolicyEditorScopes;
69 import org.onap.policy.rest.jpa.PolicyEntity;
70 import org.onap.policy.rest.jpa.PolicyVersion;
71 import org.onap.policy.rest.jpa.UserInfo;
72 import org.onap.policy.utils.UserUtils.Pair;
73 import org.onap.portalsdk.core.domain.User;
74 import org.onap.portalsdk.core.util.SystemProperties;
75 import org.powermock.reflect.Whitebox;
76 import org.springframework.mock.web.MockHttpServletResponse;
78 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
79 public class PolicyManagerServletTest extends Mockito {
81 private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
82 private List<String> headers = new ArrayList<String>();
84 private static List<Object> rolesdata;
85 private static List<Object> basePolicyData;
86 private static List<Object> policyEditorScopes;
87 private static List<Object> policyVersion;
88 private static CommonClassDao commonClassDao;
89 private ConfigurationDataEntity configurationEntity;
90 private HttpServletRequest request;
91 private MockHttpServletResponse response;
96 * @throws Exception should not get one
99 public void setUp() throws Exception {
100 logger.info("setUp: Entering");
102 request = mock(HttpServletRequest.class);
103 response = new MockHttpServletResponse();
105 PolicyController.setjUnit(true);
106 UserInfo userinfo = new UserInfo();
107 userinfo.setUserLoginId("Test");
108 userinfo.setUserName("Test");
110 rolesdata = new ArrayList<>();
111 Roles roles = new Roles();
112 roles.setLoginId("Test");
113 roles.setRole("super-admin");
114 Roles roles1 = new Roles();
116 roles1.setName("Test");
117 assertTrue("Test".equals(roles1.getName()));
118 roles1.setLoginId("Test");
119 roles1.setRole("admin");
120 roles1.setScope("['com','Test']");
121 rolesdata.add(roles);
122 rolesdata.add(roles1);
125 basePolicyData = new ArrayList<>();
126 String policyContent = "";
128 ClassLoader classLoader = getClass().getClassLoader();
129 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
130 } catch (Exception e1) {
131 logger.error("Exception Occured" + e1);
133 PolicyEntity entity = new PolicyEntity();
134 entity.setPolicyName("Config_SampleTest.1.xml");
135 entity.setPolicyData(policyContent);
136 entity.setScope("com");
137 configurationEntity = new ConfigurationDataEntity();
138 configurationEntity.setConfigBody("Sample Test");
139 configurationEntity.setConfigType("OTHER");
140 configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
141 configurationEntity.setDescription("test");
142 entity.setConfigurationData(configurationEntity);
143 basePolicyData.add(entity);
145 // PolicyEditorScopes data
146 policyEditorScopes = new ArrayList<>();
147 PolicyEditorScopes scopes = new PolicyEditorScopes();
148 scopes.setScopeName("com");
149 scopes.setUserCreatedBy(userinfo);
150 scopes.setUserModifiedBy(userinfo);
151 PolicyEditorScopes scopes1 = new PolicyEditorScopes();
152 scopes1.setScopeName("com\\Test");
153 scopes1.setUserCreatedBy(userinfo);
154 scopes1.setUserModifiedBy(userinfo);
155 policyEditorScopes.add(scopes);
156 policyEditorScopes.add(scopes1);
158 // PolicyVersion data
159 policyVersion = new ArrayList<>();
160 PolicyVersion policy = new PolicyVersion();
161 policy.setPolicyName("com\\Config_SampleTest1206");
162 policy.setActiveVersion(1);
163 policy.setHigherVersion(1);
164 policy.setCreatedBy("Test");
165 policy.setModifiedBy("Test");
166 policyVersion.add(policy);
168 HttpSession mockSession = mock(HttpSession.class);
169 User user = new User();
170 user.setOrgUserId("Test");
171 Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
172 Mockito.when(request.getSession(false)).thenReturn(mockSession);
173 commonClassDao = mock(CommonClassDao.class);
178 public void test01Init() {
179 PolicyManagerServlet servlet = new PolicyManagerServlet();
180 ServletConfig servletConfig = mock(ServletConfig.class);
182 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
183 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
184 System.setProperty("xacml.rest.admin.closedLoopJSON",
185 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
186 + "resources" + File.separator + "JSONConfig.json");
187 servlet.init(servletConfig);
189 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
190 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
192 } catch (Exception e1) {
193 logger.error("Exception Occured" + e1);
199 public void test02BadInitJson() {
200 PolicyManagerServlet servlet = new PolicyManagerServlet();
201 ServletConfig servletConfig = mock(ServletConfig.class);
203 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
204 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
205 System.setProperty("xacml.rest.admin.closedLoopJSON",
206 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
207 + "resources" + File.separator + "JSONConfig.foo");
208 servlet.init(servletConfig);
209 } catch (Exception e1) {
210 logger.error("Exception Occured" + e1);
216 public void test03BadInitJsonInvalidFile() {
217 PolicyManagerServlet servlet = new PolicyManagerServlet();
218 ServletConfig servletConfig = mock(ServletConfig.class);
220 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
221 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
222 System.setProperty("xacml.rest.admin.closedLoopJSON",
223 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
224 + "resources" + File.separator + "IDonotExist.json");
225 servlet.init(servletConfig);
226 } catch (Exception e1) {
227 logger.error("Exception Occured" + e1);
232 @SuppressWarnings("static-access")
234 public void test04DescribePolicy() {
235 PolicyManagerServlet servlet = new PolicyManagerServlet();
236 PolicyController controller = mock(PolicyController.class);
237 BufferedReader reader = new BufferedReader(
238 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
240 when(request.getReader()).thenReturn(reader);
241 String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
242 when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
243 servlet.setPolicyController(controller);
244 servlet.doPost(request, response);
245 } catch (Exception e1) {
246 logger.error("Exception Occured" + e1);
251 @SuppressWarnings("static-access")
253 public void test05PolicyScopeList() {
254 PolicyManagerServlet servlet = new PolicyManagerServlet();
255 PolicyController controller = mock(PolicyController.class);
256 List<String> list = new ArrayList<>();
257 list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
258 list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
259 for (int i = 0; i < list.size(); i++) {
260 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
262 when(request.getReader()).thenReturn(reader);
263 when(controller.getRoles("Test")).thenReturn(rolesdata);
264 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
265 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
266 .thenReturn(policyEditorScopes);
267 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
268 .thenReturn(policyVersion);
269 servlet.setPolicyController(controller);
270 servlet.setTestUserId("Test");
271 servlet.doPost(request, response);
272 } catch (Exception e1) {
273 logger.error("Exception Occured" + e1);
279 @SuppressWarnings("static-access")
281 public void test06editBasePolicyTest() {
282 PolicyManagerServlet servlet = new PolicyManagerServlet();
283 PolicyController controller = mock(PolicyController.class);
284 List<String> list = new ArrayList<>();
285 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
286 for (int i = 0; i < list.size(); i++) {
287 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
289 when(request.getReader()).thenReturn(reader);
290 when(controller.getRoles("Test")).thenReturn(rolesdata);
291 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
292 null)).thenReturn(basePolicyData);
293 servlet.setPolicyController(controller);
294 servlet.setTestUserId("Test");
295 servlet.doPost(request, response);
296 } catch (Exception e1) {
297 logger.error("Exception Occured" + e1);
303 @SuppressWarnings("static-access")
305 public void test07editBRMSParamPolicyTest() {
306 List<Object> policyData = new ArrayList<>();
307 String policyContent = "";
308 String configData = "";
310 ClassLoader classLoader = getClass().getClassLoader();
312 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
314 .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
315 } catch (Exception e1) {
316 logger.error("Exception Occured" + e1);
318 PolicyEntity entity = new PolicyEntity();
319 entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
320 entity.setPolicyData(policyContent);
321 entity.setScope("com");
322 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
323 configurationEntity.setConfigBody(configData);
324 configurationEntity.setConfigType("OTHER");
325 configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
326 configurationEntity.setDescription("test");
327 entity.setConfigurationData(configurationEntity);
328 policyData.add(entity);
329 PolicyManagerServlet servlet = new PolicyManagerServlet();
330 PolicyController controller = mock(PolicyController.class);
331 List<String> list = new ArrayList<>();
332 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
333 + " onlyFolders: false}}");
334 for (int i = 0; i < list.size(); i++) {
335 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
337 when(request.getReader()).thenReturn(reader);
338 when(controller.getRoles("Test")).thenReturn(rolesdata);
339 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
340 null)).thenReturn(policyData);
341 servlet.setPolicyController(controller);
342 servlet.setTestUserId("Test");
343 servlet.doPost(request, response);
344 } catch (Exception e1) {
345 logger.error("Exception Occured" + e1);
351 @SuppressWarnings("static-access")
353 public void test08editBRMSRawPolicyTest() {
354 List<Object> policyData = new ArrayList<>();
355 String policyContent = "";
356 String configData = "";
358 ClassLoader classLoader = getClass().getClassLoader();
360 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
362 IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
363 } catch (Exception e1) {
364 logger.error("Exception Occured" + e1);
366 PolicyEntity entity = new PolicyEntity();
367 entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
368 entity.setPolicyData(policyContent);
369 entity.setScope("com");
370 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
371 configurationEntity.setConfigBody(configData);
372 configurationEntity.setConfigType("OTHER");
373 configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
374 configurationEntity.setDescription("test");
375 entity.setConfigurationData(configurationEntity);
376 policyData.add(entity);
377 PolicyManagerServlet servlet = new PolicyManagerServlet();
378 PolicyController controller = mock(PolicyController.class);
379 List<String> list = new ArrayList<>();
380 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
381 + " onlyFolders: false}}");
382 for (int i = 0; i < list.size(); i++) {
383 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
385 when(request.getReader()).thenReturn(reader);
386 when(controller.getRoles("Test")).thenReturn(rolesdata);
387 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
388 null)).thenReturn(policyData);
389 servlet.setPolicyController(controller);
390 servlet.setTestUserId("Test");
391 servlet.doPost(request, response);
392 } catch (Exception e1) {
393 logger.error("Exception Occured" + e1);
399 @SuppressWarnings("static-access")
401 public void test09editClosedLoopFaultPolicyTest() {
402 List<Object> policyData = new ArrayList<>();
403 String policyContent = "";
404 String configData = "";
406 ClassLoader classLoader = getClass().getClassLoader();
408 IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
410 IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
411 } catch (Exception e1) {
412 logger.error("Exception Occured" + e1);
414 PolicyEntity entity = new PolicyEntity();
415 entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
416 entity.setPolicyData(policyContent);
417 entity.setScope("com");
418 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
419 configurationEntity.setConfigBody(configData);
420 configurationEntity.setConfigType("JSON");
421 configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
422 configurationEntity.setDescription("test");
423 entity.setConfigurationData(configurationEntity);
424 policyData.add(entity);
425 PolicyManagerServlet servlet = new PolicyManagerServlet();
426 PolicyController controller = mock(PolicyController.class);
427 List<String> list = new ArrayList<>();
428 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
429 + " onlyFolders: false}}");
430 for (int i = 0; i < list.size(); i++) {
431 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
433 when(request.getReader()).thenReturn(reader);
434 when(controller.getRoles("Test")).thenReturn(rolesdata);
435 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
436 null)).thenReturn(policyData);
437 servlet.setPolicyController(controller);
438 servlet.setTestUserId("Test");
439 servlet.doPost(request, response);
440 } catch (Exception e1) {
441 logger.error("Exception Occured" + e1);
447 @SuppressWarnings("static-access")
449 public void test10editClosedLoopPMPolicyTest() {
450 List<Object> policyData = new ArrayList<>();
451 String policyContent = "";
452 String configData = "";
454 ClassLoader classLoader = getClass().getClassLoader();
455 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
457 IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
458 } catch (Exception e1) {
459 logger.error("Exception Occured" + e1);
461 PolicyEntity entity = new PolicyEntity();
462 entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
463 entity.setPolicyData(policyContent);
464 entity.setScope("com");
465 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
466 configurationEntity.setConfigBody(configData);
467 configurationEntity.setConfigType("JSON");
468 configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
469 configurationEntity.setDescription("test");
470 entity.setConfigurationData(configurationEntity);
471 policyData.add(entity);
472 PolicyManagerServlet servlet = new PolicyManagerServlet();
473 PolicyController controller = mock(PolicyController.class);
474 List<String> list = new ArrayList<>();
475 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
476 + " onlyFolders: false}}");
477 for (int i = 0; i < list.size(); i++) {
478 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
480 when(request.getReader()).thenReturn(reader);
481 when(controller.getRoles("Test")).thenReturn(rolesdata);
482 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
483 null)).thenReturn(policyData);
484 servlet.setPolicyController(controller);
485 servlet.setTestUserId("Test");
486 servlet.doPost(request, response);
487 } catch (Exception e1) {
488 logger.error("Exception Occured" + e1);
494 @SuppressWarnings("static-access")
496 public void test11editMicroServicePolicyTest() {
497 GroupPolicyScopeList groupData = new GroupPolicyScopeList();
498 groupData.setGroupName("Test");
499 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
500 + "closedLoopControlName=SampleClosedLoop");
501 List<Object> groupListData = new ArrayList<>();
502 groupListData.add(groupData);
503 commonClassDao = mock(CommonClassDao.class);
504 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
505 List<Object> policyData = new ArrayList<>();
506 String policyContent = "";
507 String configData = "";
509 ClassLoader classLoader = getClass().getClassLoader();
510 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
511 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
512 } catch (Exception e1) {
513 logger.error("Exception Occured" + e1);
515 PolicyEntity entity = new PolicyEntity();
516 entity.setPolicyName("Config_MS_vFirewall.1.xml");
517 entity.setPolicyData(policyContent);
518 entity.setScope("com");
519 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
520 configurationEntity.setConfigBody(configData);
521 configurationEntity.setConfigType("JSON");
522 configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
523 configurationEntity.setDescription("test");
524 entity.setConfigurationData(configurationEntity);
525 policyData.add(entity);
526 PolicyManagerServlet servlet = new PolicyManagerServlet();
527 PolicyController controller = mock(PolicyController.class);
528 List<String> list = new ArrayList<>();
529 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
530 for (int i = 0; i < list.size(); i++) {
531 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
533 when(request.getReader()).thenReturn(reader);
534 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
535 "resource=SampleResource,service=SampleService,type=SampleType,"
536 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
537 when(controller.getRoles("Test")).thenReturn(rolesdata);
538 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
539 null)).thenReturn(policyData);
540 servlet.setPolicyController(controller);
541 servlet.setTestUserId("Test");
542 servlet.doPost(request, response);
543 } catch (Exception e1) {
544 logger.error("Exception Occured" + e1);
550 @SuppressWarnings("static-access")
552 public void test12editFirewallPolicyTest() {
553 List<Object> policyData = new ArrayList<>();
554 String policyContent = "";
555 String configData = "";
557 ClassLoader classLoader = getClass().getClassLoader();
558 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
559 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
560 } catch (Exception e1) {
561 logger.error("Exception Occured" + e1);
563 PolicyEntity entity = new PolicyEntity();
564 entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
565 entity.setPolicyData(policyContent);
566 entity.setScope("com");
567 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
568 configurationEntity.setConfigBody(configData);
569 configurationEntity.setConfigType("JSON");
570 configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
571 configurationEntity.setDescription("test");
572 entity.setConfigurationData(configurationEntity);
573 policyData.add(entity);
574 PolicyManagerServlet servlet = new PolicyManagerServlet();
575 PolicyController controller = mock(PolicyController.class);
576 List<String> list = new ArrayList<>();
577 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
578 + " onlyFolders: false}}");
579 for (int i = 0; i < list.size(); i++) {
580 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
582 when(request.getReader()).thenReturn(reader);
583 when(controller.getRoles("Test")).thenReturn(rolesdata);
584 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
585 null)).thenReturn(policyData);
586 servlet.setPolicyController(controller);
587 servlet.setTestUserId("Test");
588 servlet.doPost(request, response);
589 } catch (Exception e1) {
590 logger.error("Exception Occured" + e1);
596 @SuppressWarnings("static-access")
598 public void test13editActionPolicyTest() {
599 List<Object> policyData = new ArrayList<>();
600 String policyContent = "";
601 String configData = "";
603 ClassLoader classLoader = getClass().getClassLoader();
604 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
605 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
606 } catch (Exception e1) {
607 logger.error("Exception Occured" + e1);
609 PolicyEntity entity = new PolicyEntity();
610 entity.setPolicyName("Action_TestActionPolicy.1.xml");
611 entity.setPolicyData(policyContent);
612 entity.setScope("com");
613 ActionBodyEntity configurationEntity = new ActionBodyEntity();
614 configurationEntity.setActionBody(configData);
615 configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
616 entity.setActionBodyEntity(configurationEntity);
617 policyData.add(entity);
618 PolicyManagerServlet servlet = new PolicyManagerServlet();
619 PolicyController controller = mock(PolicyController.class);
620 List<String> list = new ArrayList<>();
621 list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
622 for (int i = 0; i < list.size(); i++) {
623 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
625 when(request.getReader()).thenReturn(reader);
626 when(controller.getRoles("Test")).thenReturn(rolesdata);
627 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
628 null)).thenReturn(policyData);
629 servlet.setPolicyController(controller);
630 servlet.setTestUserId("Test");
631 servlet.doPost(request, response);
632 } catch (Exception e1) {
633 logger.error("Exception Occured" + e1);
639 @SuppressWarnings("static-access")
641 public void test14editDecisionPolicyTest() {
642 List<Object> policyData = new ArrayList<>();
643 String policyContent = "";
645 ClassLoader classLoader = getClass().getClassLoader();
646 policyContent = IOUtils
647 .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
648 } catch (Exception e1) {
649 logger.error("Exception Occured" + e1);
651 PolicyEntity entity = new PolicyEntity();
652 entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
653 entity.setPolicyData(policyContent);
654 entity.setScope("com");
655 policyData.add(entity);
656 PolicyManagerServlet servlet = new PolicyManagerServlet();
657 PolicyController controller = mock(PolicyController.class);
658 List<String> list = new ArrayList<>();
659 list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
660 + " onlyFolders: false}}");
661 for (int i = 0; i < list.size(); i++) {
662 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
664 when(request.getReader()).thenReturn(reader);
665 when(controller.getRoles("Test")).thenReturn(rolesdata);
666 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
667 null)).thenReturn(policyData);
668 servlet.setPolicyController(controller);
669 servlet.setTestUserId("Test");
670 servlet.doPost(request, response);
671 } catch (Exception e1) {
672 logger.error("Exception Occured" + e1);
679 public void test15AddScope() {
680 PolicyManagerServlet servlet = new PolicyManagerServlet();
681 PolicyController controller = mock(PolicyController.class);
682 List<BufferedReader> readers = new ArrayList<>();
683 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
684 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
685 readers.add(new BufferedReader(
686 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
687 for (int i = 0; i < readers.size(); i++) {
689 when(request.getReader()).thenReturn(readers.get(i));
690 PolicyManagerServlet.setPolicyController(controller);
691 servlet.doPost(request, response);
692 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
693 } catch (Exception e1) {
694 logger.error("Exception Occured" + e1);
701 public void test16Clone() {
702 PolicyManagerServlet servlet = new PolicyManagerServlet();
703 PolicyController controller = mock(PolicyController.class);
704 List<BufferedReader> readers = new ArrayList<>();
705 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
706 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
707 when(controller.getDataByQuery(
708 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
709 .thenReturn(basePolicyData);
710 readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
711 + " newPath: 'com.Config_testClone.1.xml'}}")));
712 for (int i = 0; i < readers.size(); i++) {
714 when(request.getReader()).thenReturn(readers.get(i));
715 PolicyManagerServlet.setPolicyController(controller);
716 servlet.doPost(request, response);
717 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
718 } catch (Exception e1) {
719 logger.error("Exception Occured" + e1);
726 public void test17Rename() {
727 PolicyManagerServlet servlet = new PolicyManagerServlet();
728 PolicyController controller = mock(PolicyController.class);
729 List<BufferedReader> readers = new ArrayList<>();
730 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
731 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
732 when(controller.getDataByQuery(
733 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
734 .thenReturn(basePolicyData);
735 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
736 + " newPath: 'com.Config_testClone.1.xml'}}")));
737 for (int i = 0; i < readers.size(); i++) {
739 when(request.getReader()).thenReturn(readers.get(i));
740 PolicyManagerServlet.setPolicyController(controller);
741 servlet.doPost(request, response);
742 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
743 } catch (Exception e1) {
744 logger.error("Exception Occured" + e1);
751 public void test18RenameScope() throws Exception {
752 PolicyManagerServlet servlet = new PolicyManagerServlet();
753 PolicyController controller = mock(PolicyController.class);
754 List<BufferedReader> readers = new ArrayList<>();
755 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
756 for (int i = 0; i < readers.size(); i++) {
758 when(request.getReader()).thenReturn(readers.get(i));
759 PolicyManagerServlet.setPolicyController(controller);
760 servlet.doPost(request, response);
761 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
762 } catch (Exception e1) {
763 logger.error("Exception Occured" + e1);
768 String inScopeName = "\\\\\\\\inScopeName";
769 String newScopeName = "\\\\\\\\newScopeName";
770 List<Object> scopesList = new ArrayList<Object>();
771 PolicyEditorScopes mockPolicyEditorScope = Mockito.mock(PolicyEditorScopes.class);
772 scopesList.add(mockPolicyEditorScope);
773 when(mockPolicyEditorScope.getScopeName()).thenReturn("inScopeName");
774 Whitebox.invokeMethod(servlet, "renameScope", scopesList, inScopeName, newScopeName, controller);
775 verify(mockPolicyEditorScope, atLeast(1)).getScopeName();
779 public void test19SetPolicyNames() {
780 JsonArray mockJsonArray = Mockito.mock(JsonArray.class);
781 PolicyManagerServlet.setPolicyNames(mockJsonArray);
782 assertEquals(mockJsonArray, PolicyManagerServlet.getPolicyNames());
786 public void test20DoPostSetErrorException() throws IOException {
787 PolicyManagerServlet servlet = new PolicyManagerServlet();
788 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
789 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
790 doThrow(IOException.class).when(mockRequest).getReader();
791 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
792 servlet.doPost(mockRequest, mockResponse);
793 verify(mockRequest).getReader();
797 public void test21DoPostException() throws IOException {
798 PolicyManagerServlet servlet = new PolicyManagerServlet();
799 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
800 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
802 doThrow(IOException.class).when(mockRequest).getReader();
803 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
804 doThrow(IOException.class).when(mockResponse).getWriter();
806 servlet.doPost(mockRequest, mockResponse);
807 verify(mockRequest).getReader();
808 verify(mockResponse).getWriter();
812 public void test22DoPostSuccess() throws IOException {
813 PolicyManagerServlet servlet = new PolicyManagerServlet();
814 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
815 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
816 PrintWriter mockPrintWriter = Mockito.mock(PrintWriter.class);
818 doThrow(IOException.class).when(mockRequest).getReader();
819 when(mockResponse.getWriter()).thenReturn(mockPrintWriter);
821 servlet.doPost(null, mockResponse);
822 verify(mockResponse).getWriter();
826 public void test23DoPostUploadFileException() {
827 PolicyManagerServlet servlet = new PolicyManagerServlet() {
828 private static final long serialVersionUID = 1L;
830 protected boolean isMultipartContent(HttpServletRequest request) {
834 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
835 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
836 servlet.doPost(mockRequest, mockResponse);
840 public void test24ProcessFormFile() throws Exception {
841 long fileSizeLimit = 10;
843 PolicyManagerServlet servlet = new PolicyManagerServlet() {
844 private static final long serialVersionUID = 1L;
847 protected long getFileSizeLimit() {
848 return fileSizeLimit;
852 protected long copyStream(InputStream inputStream, OutputStream outputStream) throws IOException {
853 // don't really copy the file
857 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.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);
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);
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);
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();