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.AfterClass;
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;
98 public static void tearDown() {
99 File destroyFile = new File("testFileName.xls");
100 destroyFile.deleteOnExit();
106 * @throws Exception should not get one
109 public void setUp() throws Exception {
110 logger.info("setUp: Entering");
112 request = mock(HttpServletRequest.class);
113 response = new MockHttpServletResponse();
115 PolicyController.setjUnit(true);
116 UserInfo userinfo = new UserInfo();
117 userinfo.setUserLoginId("Test");
118 userinfo.setUserName("Test");
120 rolesdata = new ArrayList<>();
121 Roles roles = new Roles();
122 roles.setLoginId("Test");
123 roles.setRole("super-admin");
124 Roles roles1 = new Roles();
126 roles1.setName("Test");
127 assertTrue("Test".equals(roles1.getName()));
128 roles1.setLoginId("Test");
129 roles1.setRole("admin");
130 roles1.setScope("['com','Test']");
131 rolesdata.add(roles);
132 rolesdata.add(roles1);
135 basePolicyData = new ArrayList<>();
136 String policyContent = "";
138 ClassLoader classLoader = getClass().getClassLoader();
139 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
140 } catch (Exception e1) {
141 logger.error("Exception Occured" + e1);
143 PolicyEntity entity = new PolicyEntity();
144 entity.setPolicyName("Config_SampleTest.1.xml");
145 entity.setPolicyData(policyContent);
146 entity.setScope("com");
147 configurationEntity = new ConfigurationDataEntity();
148 configurationEntity.setConfigBody("Sample Test");
149 configurationEntity.setConfigType("OTHER");
150 configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
151 configurationEntity.setDescription("test");
152 entity.setConfigurationData(configurationEntity);
153 basePolicyData.add(entity);
155 // PolicyEditorScopes data
156 policyEditorScopes = new ArrayList<>();
157 PolicyEditorScopes scopes = new PolicyEditorScopes();
158 scopes.setScopeName("com");
159 scopes.setUserCreatedBy(userinfo);
160 scopes.setUserModifiedBy(userinfo);
161 PolicyEditorScopes scopes1 = new PolicyEditorScopes();
162 scopes1.setScopeName("com\\Test");
163 scopes1.setUserCreatedBy(userinfo);
164 scopes1.setUserModifiedBy(userinfo);
165 policyEditorScopes.add(scopes);
166 policyEditorScopes.add(scopes1);
168 // PolicyVersion data
169 policyVersion = new ArrayList<>();
170 PolicyVersion policy = new PolicyVersion();
171 policy.setPolicyName("com\\Config_SampleTest1206");
172 policy.setActiveVersion(1);
173 policy.setHigherVersion(1);
174 policy.setCreatedBy("Test");
175 policy.setModifiedBy("Test");
176 policyVersion.add(policy);
178 HttpSession mockSession = mock(HttpSession.class);
179 User user = new User();
180 user.setOrgUserId("Test");
181 Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
182 Mockito.when(request.getSession(false)).thenReturn(mockSession);
183 commonClassDao = mock(CommonClassDao.class);
188 public void test01Init() {
189 PolicyManagerServlet servlet = new PolicyManagerServlet();
190 ServletConfig servletConfig = mock(ServletConfig.class);
192 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
193 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
194 System.setProperty("xacml.rest.admin.closedLoopJSON",
195 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
196 + "resources" + File.separator + "JSONConfig.json");
197 servlet.init(servletConfig);
199 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
200 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
202 } catch (Exception e1) {
203 logger.error("Exception Occured" + e1);
209 public void test02BadInitJson() {
210 PolicyManagerServlet servlet = new PolicyManagerServlet();
211 ServletConfig servletConfig = mock(ServletConfig.class);
213 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
214 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
215 System.setProperty("xacml.rest.admin.closedLoopJSON",
216 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
217 + "resources" + File.separator + "JSONConfig.foo");
218 servlet.init(servletConfig);
219 } catch (Exception e1) {
220 logger.error("Exception Occured" + e1);
226 public void test03BadInitJsonInvalidFile() {
227 PolicyManagerServlet servlet = new PolicyManagerServlet();
228 ServletConfig servletConfig = mock(ServletConfig.class);
230 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
231 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
232 System.setProperty("xacml.rest.admin.closedLoopJSON",
233 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
234 + "resources" + File.separator + "IDonotExist.json");
235 servlet.init(servletConfig);
236 } catch (Exception e1) {
237 logger.error("Exception Occured" + e1);
242 @SuppressWarnings("static-access")
244 public void test04DescribePolicy() {
245 PolicyManagerServlet servlet = new PolicyManagerServlet();
246 PolicyController controller = mock(PolicyController.class);
247 BufferedReader reader = new BufferedReader(
248 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
250 when(request.getReader()).thenReturn(reader);
251 String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
252 when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
253 servlet.setPolicyController(controller);
254 servlet.doPost(request, response);
255 } catch (Exception e1) {
256 logger.error("Exception Occured" + e1);
261 @SuppressWarnings("static-access")
263 public void test05PolicyScopeList() {
264 PolicyManagerServlet servlet = new PolicyManagerServlet();
265 PolicyController controller = mock(PolicyController.class);
266 List<String> list = new ArrayList<>();
267 list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
268 list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
269 for (int i = 0; i < list.size(); i++) {
270 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
272 when(request.getReader()).thenReturn(reader);
273 when(controller.getRoles("Test")).thenReturn(rolesdata);
274 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
275 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
276 .thenReturn(policyEditorScopes);
277 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
278 .thenReturn(policyVersion);
279 servlet.setPolicyController(controller);
280 servlet.setTestUserId("Test");
281 servlet.doPost(request, response);
282 } catch (Exception e1) {
283 logger.error("Exception Occured" + e1);
289 @SuppressWarnings("static-access")
291 public void test06editBasePolicyTest() {
292 PolicyManagerServlet servlet = new PolicyManagerServlet();
293 PolicyController controller = mock(PolicyController.class);
294 List<String> list = new ArrayList<>();
295 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
296 for (int i = 0; i < list.size(); i++) {
297 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
299 when(request.getReader()).thenReturn(reader);
300 when(controller.getRoles("Test")).thenReturn(rolesdata);
301 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
302 null)).thenReturn(basePolicyData);
303 servlet.setPolicyController(controller);
304 servlet.setTestUserId("Test");
305 servlet.doPost(request, response);
306 } catch (Exception e1) {
307 logger.error("Exception Occured" + e1);
313 @SuppressWarnings("static-access")
315 public void test07editBRMSParamPolicyTest() {
316 List<Object> policyData = new ArrayList<>();
317 String policyContent = "";
318 String configData = "";
320 ClassLoader classLoader = getClass().getClassLoader();
322 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
324 .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
325 } catch (Exception e1) {
326 logger.error("Exception Occured" + e1);
328 PolicyEntity entity = new PolicyEntity();
329 entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
330 entity.setPolicyData(policyContent);
331 entity.setScope("com");
332 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
333 configurationEntity.setConfigBody(configData);
334 configurationEntity.setConfigType("OTHER");
335 configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
336 configurationEntity.setDescription("test");
337 entity.setConfigurationData(configurationEntity);
338 policyData.add(entity);
339 PolicyManagerServlet servlet = new PolicyManagerServlet();
340 PolicyController controller = mock(PolicyController.class);
341 List<String> list = new ArrayList<>();
342 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
343 + " onlyFolders: false}}");
344 for (int i = 0; i < list.size(); i++) {
345 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
347 when(request.getReader()).thenReturn(reader);
348 when(controller.getRoles("Test")).thenReturn(rolesdata);
349 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
350 null)).thenReturn(policyData);
351 servlet.setPolicyController(controller);
352 servlet.setTestUserId("Test");
353 servlet.doPost(request, response);
354 } catch (Exception e1) {
355 logger.error("Exception Occured" + e1);
361 @SuppressWarnings("static-access")
363 public void test08editBRMSRawPolicyTest() {
364 List<Object> policyData = new ArrayList<>();
365 String policyContent = "";
366 String configData = "";
368 ClassLoader classLoader = getClass().getClassLoader();
370 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
372 IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
373 } catch (Exception e1) {
374 logger.error("Exception Occured" + e1);
376 PolicyEntity entity = new PolicyEntity();
377 entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
378 entity.setPolicyData(policyContent);
379 entity.setScope("com");
380 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
381 configurationEntity.setConfigBody(configData);
382 configurationEntity.setConfigType("OTHER");
383 configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
384 configurationEntity.setDescription("test");
385 entity.setConfigurationData(configurationEntity);
386 policyData.add(entity);
387 PolicyManagerServlet servlet = new PolicyManagerServlet();
388 PolicyController controller = mock(PolicyController.class);
389 List<String> list = new ArrayList<>();
390 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
391 + " onlyFolders: false}}");
392 for (int i = 0; i < list.size(); i++) {
393 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
395 when(request.getReader()).thenReturn(reader);
396 when(controller.getRoles("Test")).thenReturn(rolesdata);
397 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
398 null)).thenReturn(policyData);
399 servlet.setPolicyController(controller);
400 servlet.setTestUserId("Test");
401 servlet.doPost(request, response);
402 } catch (Exception e1) {
403 logger.error("Exception Occured" + e1);
409 @SuppressWarnings("static-access")
411 public void test09editClosedLoopFaultPolicyTest() {
412 List<Object> policyData = new ArrayList<>();
413 String policyContent = "";
414 String configData = "";
416 ClassLoader classLoader = getClass().getClassLoader();
418 IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
420 IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
421 } catch (Exception e1) {
422 logger.error("Exception Occured" + e1);
424 PolicyEntity entity = new PolicyEntity();
425 entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
426 entity.setPolicyData(policyContent);
427 entity.setScope("com");
428 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
429 configurationEntity.setConfigBody(configData);
430 configurationEntity.setConfigType("JSON");
431 configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
432 configurationEntity.setDescription("test");
433 entity.setConfigurationData(configurationEntity);
434 policyData.add(entity);
435 PolicyManagerServlet servlet = new PolicyManagerServlet();
436 PolicyController controller = mock(PolicyController.class);
437 List<String> list = new ArrayList<>();
438 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
439 + " onlyFolders: false}}");
440 for (int i = 0; i < list.size(); i++) {
441 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
443 when(request.getReader()).thenReturn(reader);
444 when(controller.getRoles("Test")).thenReturn(rolesdata);
445 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
446 null)).thenReturn(policyData);
447 servlet.setPolicyController(controller);
448 servlet.setTestUserId("Test");
449 servlet.doPost(request, response);
450 } catch (Exception e1) {
451 logger.error("Exception Occured" + e1);
457 @SuppressWarnings("static-access")
459 public void test10editClosedLoopPMPolicyTest() {
460 List<Object> policyData = new ArrayList<>();
461 String policyContent = "";
462 String configData = "";
464 ClassLoader classLoader = getClass().getClassLoader();
465 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
467 IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
468 } catch (Exception e1) {
469 logger.error("Exception Occured" + e1);
471 PolicyEntity entity = new PolicyEntity();
472 entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
473 entity.setPolicyData(policyContent);
474 entity.setScope("com");
475 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
476 configurationEntity.setConfigBody(configData);
477 configurationEntity.setConfigType("JSON");
478 configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
479 configurationEntity.setDescription("test");
480 entity.setConfigurationData(configurationEntity);
481 policyData.add(entity);
482 PolicyManagerServlet servlet = new PolicyManagerServlet();
483 PolicyController controller = mock(PolicyController.class);
484 List<String> list = new ArrayList<>();
485 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
486 + " onlyFolders: false}}");
487 for (int i = 0; i < list.size(); i++) {
488 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
490 when(request.getReader()).thenReturn(reader);
491 when(controller.getRoles("Test")).thenReturn(rolesdata);
492 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
493 null)).thenReturn(policyData);
494 servlet.setPolicyController(controller);
495 servlet.setTestUserId("Test");
496 servlet.doPost(request, response);
497 } catch (Exception e1) {
498 logger.error("Exception Occured" + e1);
504 @SuppressWarnings("static-access")
506 public void test11editMicroServicePolicyTest() {
507 GroupPolicyScopeList groupData = new GroupPolicyScopeList();
508 groupData.setGroupName("Test");
509 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
510 + "closedLoopControlName=SampleClosedLoop");
511 List<Object> groupListData = new ArrayList<>();
512 groupListData.add(groupData);
513 commonClassDao = mock(CommonClassDao.class);
514 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
515 List<Object> policyData = new ArrayList<>();
516 String policyContent = "";
517 String configData = "";
519 ClassLoader classLoader = getClass().getClassLoader();
520 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
521 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
522 } catch (Exception e1) {
523 logger.error("Exception Occured" + e1);
525 PolicyEntity entity = new PolicyEntity();
526 entity.setPolicyName("Config_MS_vFirewall.1.xml");
527 entity.setPolicyData(policyContent);
528 entity.setScope("com");
529 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
530 configurationEntity.setConfigBody(configData);
531 configurationEntity.setConfigType("JSON");
532 configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
533 configurationEntity.setDescription("test");
534 entity.setConfigurationData(configurationEntity);
535 policyData.add(entity);
536 PolicyManagerServlet servlet = new PolicyManagerServlet();
537 PolicyController controller = mock(PolicyController.class);
538 List<String> list = new ArrayList<>();
539 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
540 for (int i = 0; i < list.size(); i++) {
541 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
543 when(request.getReader()).thenReturn(reader);
544 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
545 "resource=SampleResource,service=SampleService,type=SampleType,"
546 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
547 when(controller.getRoles("Test")).thenReturn(rolesdata);
548 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
549 null)).thenReturn(policyData);
550 servlet.setPolicyController(controller);
551 servlet.setTestUserId("Test");
552 servlet.doPost(request, response);
553 } catch (Exception e1) {
554 logger.error("Exception Occured" + e1);
560 @SuppressWarnings("static-access")
562 public void test12editFirewallPolicyTest() {
563 List<Object> policyData = new ArrayList<>();
564 String policyContent = "";
565 String configData = "";
567 ClassLoader classLoader = getClass().getClassLoader();
568 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
569 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
570 } catch (Exception e1) {
571 logger.error("Exception Occured" + e1);
573 PolicyEntity entity = new PolicyEntity();
574 entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
575 entity.setPolicyData(policyContent);
576 entity.setScope("com");
577 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
578 configurationEntity.setConfigBody(configData);
579 configurationEntity.setConfigType("JSON");
580 configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
581 configurationEntity.setDescription("test");
582 entity.setConfigurationData(configurationEntity);
583 policyData.add(entity);
584 PolicyManagerServlet servlet = new PolicyManagerServlet();
585 PolicyController controller = mock(PolicyController.class);
586 List<String> list = new ArrayList<>();
587 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
588 + " onlyFolders: false}}");
589 for (int i = 0; i < list.size(); i++) {
590 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
592 when(request.getReader()).thenReturn(reader);
593 when(controller.getRoles("Test")).thenReturn(rolesdata);
594 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
595 null)).thenReturn(policyData);
596 servlet.setPolicyController(controller);
597 servlet.setTestUserId("Test");
598 servlet.doPost(request, response);
599 } catch (Exception e1) {
600 logger.error("Exception Occured" + e1);
606 @SuppressWarnings("static-access")
608 public void test13editActionPolicyTest() {
609 List<Object> policyData = new ArrayList<>();
610 String policyContent = "";
611 String configData = "";
613 ClassLoader classLoader = getClass().getClassLoader();
614 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
615 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
616 } catch (Exception e1) {
617 logger.error("Exception Occured" + e1);
619 PolicyEntity entity = new PolicyEntity();
620 entity.setPolicyName("Action_TestActionPolicy.1.xml");
621 entity.setPolicyData(policyContent);
622 entity.setScope("com");
623 ActionBodyEntity configurationEntity = new ActionBodyEntity();
624 configurationEntity.setActionBody(configData);
625 configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
626 entity.setActionBodyEntity(configurationEntity);
627 policyData.add(entity);
628 PolicyManagerServlet servlet = new PolicyManagerServlet();
629 PolicyController controller = mock(PolicyController.class);
630 List<String> list = new ArrayList<>();
631 list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
632 for (int i = 0; i < list.size(); i++) {
633 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
635 when(request.getReader()).thenReturn(reader);
636 when(controller.getRoles("Test")).thenReturn(rolesdata);
637 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
638 null)).thenReturn(policyData);
639 servlet.setPolicyController(controller);
640 servlet.setTestUserId("Test");
641 servlet.doPost(request, response);
642 } catch (Exception e1) {
643 logger.error("Exception Occured" + e1);
649 @SuppressWarnings("static-access")
651 public void test14editDecisionPolicyTest() {
652 List<Object> policyData = new ArrayList<>();
653 String policyContent = "";
655 ClassLoader classLoader = getClass().getClassLoader();
656 policyContent = IOUtils
657 .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
658 } catch (Exception e1) {
659 logger.error("Exception Occured" + e1);
661 PolicyEntity entity = new PolicyEntity();
662 entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
663 entity.setPolicyData(policyContent);
664 entity.setScope("com");
665 policyData.add(entity);
666 PolicyManagerServlet servlet = new PolicyManagerServlet();
667 PolicyController controller = mock(PolicyController.class);
668 List<String> list = new ArrayList<>();
669 list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
670 + " onlyFolders: false}}");
671 for (int i = 0; i < list.size(); i++) {
672 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
674 when(request.getReader()).thenReturn(reader);
675 when(controller.getRoles("Test")).thenReturn(rolesdata);
676 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
677 null)).thenReturn(policyData);
678 servlet.setPolicyController(controller);
679 servlet.setTestUserId("Test");
680 servlet.doPost(request, response);
681 } catch (Exception e1) {
682 logger.error("Exception Occured" + e1);
689 public void test15AddScope() {
690 PolicyManagerServlet servlet = new PolicyManagerServlet();
691 PolicyController controller = mock(PolicyController.class);
692 List<BufferedReader> readers = new ArrayList<>();
693 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
694 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
695 readers.add(new BufferedReader(
696 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
697 for (int i = 0; i < readers.size(); i++) {
699 when(request.getReader()).thenReturn(readers.get(i));
700 PolicyManagerServlet.setPolicyController(controller);
701 servlet.doPost(request, response);
702 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
703 } catch (Exception e1) {
704 logger.error("Exception Occured" + e1);
711 public void test16Clone() {
712 PolicyManagerServlet servlet = new PolicyManagerServlet();
713 PolicyController controller = mock(PolicyController.class);
714 List<BufferedReader> readers = new ArrayList<>();
715 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
716 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
717 when(controller.getDataByQuery(
718 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
719 .thenReturn(basePolicyData);
720 readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
721 + " newPath: 'com.Config_testClone.1.xml'}}")));
722 for (int i = 0; i < readers.size(); i++) {
724 when(request.getReader()).thenReturn(readers.get(i));
725 PolicyManagerServlet.setPolicyController(controller);
726 servlet.doPost(request, response);
727 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
728 } catch (Exception e1) {
729 logger.error("Exception Occured" + e1);
736 public void test17Rename() {
737 PolicyManagerServlet servlet = new PolicyManagerServlet();
738 PolicyController controller = mock(PolicyController.class);
739 List<BufferedReader> readers = new ArrayList<>();
740 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
741 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
742 when(controller.getDataByQuery(
743 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
744 .thenReturn(basePolicyData);
745 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
746 + " newPath: 'com.Config_testClone.1.xml'}}")));
747 for (int i = 0; i < readers.size(); i++) {
749 when(request.getReader()).thenReturn(readers.get(i));
750 PolicyManagerServlet.setPolicyController(controller);
751 servlet.doPost(request, response);
752 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
753 } catch (Exception e1) {
754 logger.error("Exception Occured" + e1);
761 public void test18RenameScope() throws Exception {
762 PolicyManagerServlet servlet = new PolicyManagerServlet();
763 PolicyController controller = mock(PolicyController.class);
764 List<BufferedReader> readers = new ArrayList<>();
765 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
766 for (int i = 0; i < readers.size(); i++) {
768 when(request.getReader()).thenReturn(readers.get(i));
769 PolicyManagerServlet.setPolicyController(controller);
770 servlet.doPost(request, response);
771 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
772 } catch (Exception e1) {
773 logger.error("Exception Occured" + e1);
778 String inScopeName = "\\\\\\\\inScopeName";
779 String newScopeName = "\\\\\\\\newScopeName";
780 List<Object> scopesList = new ArrayList<Object>();
781 PolicyEditorScopes mockPolicyEditorScope = Mockito.mock(PolicyEditorScopes.class);
782 scopesList.add(mockPolicyEditorScope);
783 when(mockPolicyEditorScope.getScopeName()).thenReturn("inScopeName");
784 Whitebox.invokeMethod(servlet, "renameScope", scopesList, inScopeName, newScopeName, controller);
785 verify(mockPolicyEditorScope, atLeast(1)).getScopeName();
789 public void test19SetPolicyNames() {
790 JsonArray mockJsonArray = Mockito.mock(JsonArray.class);
791 PolicyManagerServlet.setPolicyNames(mockJsonArray);
792 assertEquals(mockJsonArray, PolicyManagerServlet.getPolicyNames());
796 public void test20DoPostSetErrorException() throws IOException {
797 PolicyManagerServlet servlet = new PolicyManagerServlet();
798 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
799 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
800 doThrow(IOException.class).when(mockRequest).getReader();
801 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
802 servlet.doPost(mockRequest, mockResponse);
803 verify(mockRequest).getReader();
807 public void test21DoPostException() throws IOException {
808 PolicyManagerServlet servlet = new PolicyManagerServlet();
809 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
810 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
812 doThrow(IOException.class).when(mockRequest).getReader();
813 doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
814 doThrow(IOException.class).when(mockResponse).getWriter();
816 servlet.doPost(mockRequest, mockResponse);
817 verify(mockRequest).getReader();
818 verify(mockResponse).getWriter();
822 public void test22DoPostSuccess() throws IOException {
823 PolicyManagerServlet servlet = new PolicyManagerServlet();
824 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
825 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
826 PrintWriter mockPrintWriter = Mockito.mock(PrintWriter.class);
828 doThrow(IOException.class).when(mockRequest).getReader();
829 when(mockResponse.getWriter()).thenReturn(mockPrintWriter);
831 servlet.doPost(null, mockResponse);
832 verify(mockResponse).getWriter();
836 public void test23DoPostUploadFileException() {
837 PolicyManagerServlet servlet = new PolicyManagerServlet() {
838 private static final long serialVersionUID = 1L;
840 protected boolean isMultipartContent(HttpServletRequest request) {
844 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
845 HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
846 servlet.doPost(mockRequest, mockResponse);
850 public void test24ProcessFormFile() throws Exception {
851 long fileSizeLimit = 10;
853 PolicyManagerServlet servlet = new PolicyManagerServlet() {
854 private static final long serialVersionUID = 1L;
857 protected long getFileSizeLimit() {
858 return fileSizeLimit;
862 protected long copyStream(InputStream inputStream, OutputStream outputStream) throws IOException {
863 // don't really copy the file
867 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
868 HttpServletResponse mockResp = Mockito.mock(HttpServletResponse.class);
869 FileItem mockFileItem = Mockito.mock(FileItem.class);
870 InputStream mockInputStream = Mockito.mock(InputStream.class);
872 when(mockFileItem.getName()).thenReturn("testFileName.xls");
873 when(mockFileItem.getInputStream()).thenReturn(mockInputStream);
874 when(mockFileItem.getSize()).thenReturn(fileSizeLimit + 1);
876 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem, mockResp);
877 verify(mockFileItem, atLeast(1)).getName();
878 verify(mockFileItem, atLeast(1)).getSize();
880 when(mockFileItem.getName()).thenReturn("testFileName.txt");
881 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem, mockResp);
882 verify(mockFileItem, atLeast(1)).getName();
884 when(mockFileItem.getSize()).thenReturn(fileSizeLimit);
885 when(mockFileItem.getName()).thenReturn("testFileName.xls");
886 when(mockFileItem.getInputStream()).thenThrow(IOException.class);
887 Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem, mockResp);
888 verify(mockFileItem, atLeast(1)).getName();
889 verify(mockFileItem, atLeast(1)).getInputStream();
890 verify(mockFileItem, atLeast(1)).getSize();
894 public void test25SearchPolicyList() throws Exception {
895 PolicyManagerServlet servlet = new PolicyManagerServlet();
896 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
897 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
899 mockJSONObject.append("policyList", "sampleValue");
901 Object res = Whitebox.invokeMethod(servlet, "searchPolicyList", mockJSONObject, mockRequest);
902 assert (res instanceof JSONObject);
903 assertNotNull(((JSONObject) res).get("result"));
907 public void test26LookupPolicyData() throws Exception {
908 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
909 User mockUser = Mockito.mock(User.class);
910 UserInfo mockUserInfo = Mockito.mock(UserInfo.class);
911 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
912 List<JSONObject> resultList = new ArrayList<>();
913 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
914 resultList.add(mockJSONObject);
916 Date mockDate = Mockito.mock(Date.class);
917 List<Object> policyDataList = new ArrayList<>();
918 PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
919 policyDataList.add(mockPolicyVersion);
920 JSONArray mockJSONArray = Mockito.mock(JSONArray.class);
922 List<Object> rolesList = new ArrayList<>();
923 Roles adminRole = Mockito.mock(Roles.class);
924 Roles editorRole = Mockito.mock(Roles.class);
925 Roles guestRole = Mockito.mock(Roles.class);
926 adminRole.setRole("admin");
927 editorRole.setRole("editor");
928 guestRole.setRole("guest");
930 List<Object> filterDataList = new ArrayList<>();
931 PolicyVersion mockPolicyVersionFilter = Mockito.mock(PolicyVersion.class);
932 filterDataList.add(mockPolicyVersionFilter);
933 List<String> listOfRoles = new ArrayList<String>();
934 Set<String> setOfScopes = new HashSet<String>();
935 Pair<Set<String>, List<String>> pairList = new Pair<Set<String>, List<String>>(setOfScopes, listOfRoles);
937 PolicyManagerServlet servlet = new PolicyManagerServlet() {
938 private static final long serialVersionUID = 1L;
941 protected User getUserSession(HttpServletRequest request) {
946 protected Pair<Set<String>, List<String>> checkRoleAndScope(List<Object> userRoles) {
951 PolicyManagerServlet.setPolicyController(mockPolicyController);
952 when(mockPolicyController.getRoles(any(String.class))).thenReturn(rolesList);
953 when(mockPolicyController.getData(any(Class.class))).thenReturn(filterDataList);
954 when(mockPolicyVersion.getPolicyName()).thenReturn("sampleName");
955 when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
956 when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
957 when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
958 when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
959 when(mockPolicyController.getEntityItem(UserInfo.class, "userLoginId", "sampleUserName"))
960 .thenReturn(mockUserInfo);
961 when(mockUserInfo.getUserName()).thenReturn("testUserName");
963 Whitebox.invokeMethod(servlet, "getPolicyControllerInstance");
965 boolean result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
966 mockPolicyController, resultList);
969 verify(mockPolicyController, atLeast(1)).getRoles(any());
970 verify(mockPolicyController, atLeast(1)).getRoles(any());
971 verify(mockPolicyController, atLeast(1)).getData(any());
972 verify(mockPolicyController, atLeast(1)).getEntityItem(UserInfo.class, "userLoginId", "sampleUserName");
973 verify(mockPolicyVersion, atLeast(1)).getPolicyName();
974 verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
975 verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
976 verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
977 verify(mockPolicyVersion, atLeast(1)).getModifiedBy();
978 verify(mockUserInfo, atLeast(1)).getUserName();
980 when(mockPolicyVersionFilter.getPolicyName()).thenReturn("testAdminScope" + File.separator);
981 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
982 mockPolicyController, resultList);
984 verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
986 setOfScopes.add("testAdminScope");
987 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
988 mockPolicyController, resultList);
990 verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
992 listOfRoles.add("super-admin");
993 listOfRoles.add("super-editor");
994 listOfRoles.add("super-guest");
995 filterDataList.clear();
997 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
998 mockPolicyController, resultList);
1000 verify(mockPolicyController, atLeast(1)).getData(any(Class.class));
1002 listOfRoles.clear();
1003 listOfRoles.add("admin");
1004 listOfRoles.add("editor");
1005 listOfRoles.add("guest");
1006 setOfScopes.clear();
1007 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
1008 mockPolicyController, resultList);
1009 assertFalse(result);
1011 setOfScopes.add("testScope");
1012 result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, mockJSONArray,
1013 mockPolicyController, resultList);
1018 public void test27DeleteEntityFromEsAndPolicyEntityTable() throws Exception {
1019 PolicyManagerServlet servlet = new PolicyManagerServlet();
1020 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1021 PolicyRestController mockPolicyRestController = Mockito.mock(PolicyRestController.class);
1022 PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
1023 ConfigurationDataEntity mockConfigDataEntity = Mockito.mock(ConfigurationDataEntity.class);
1024 ActionBodyEntity mockActionBodyEntity = Mockito.mock(ActionBodyEntity.class);
1026 String policyNamewithoutExtension = "Config_";
1027 String configName = "";
1028 String actionBodyName = "";
1030 when(mockPolicyEntity.getScope()).thenReturn("");
1031 when(mockPolicyEntity.getPolicyName()).thenReturn("");
1032 Mockito.doNothing().when(mockPolicyRestController).deleteElasticData(any(String.class));
1033 Mockito.doNothing().when(mockPolicyController).deleteData(mockPolicyEntity);
1034 when(mockPolicyEntity.getConfigurationData()).thenReturn(mockConfigDataEntity);
1035 when(mockPolicyEntity.getActionBodyEntity()).thenReturn(mockActionBodyEntity);
1036 when(mockConfigDataEntity.getConfigurationName()).thenReturn(configName);
1037 when(mockActionBodyEntity.getActionBodyName()).thenReturn(actionBodyName);
1038 when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, configName)).thenReturn("");
1040 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1041 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1043 verify(mockPolicyEntity, atLeast(1)).getScope();
1044 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1045 verify(mockPolicyEntity, atLeast(1)).getConfigurationData();
1046 verify(mockConfigDataEntity, atLeast(1)).getConfigurationName();
1048 policyNamewithoutExtension = "Action_";
1049 when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, actionBodyName))
1052 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1053 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1055 verify(mockPolicyEntity, atLeast(1)).getScope();
1056 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1057 verify(mockPolicyEntity, atLeast(1)).getActionBodyEntity();
1058 verify(mockActionBodyEntity, atLeast(1)).getActionBodyName();
1060 policyNamewithoutExtension = "Other_";
1061 Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1062 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1064 verify(mockPolicyEntity, atLeast(1)).getScope();
1065 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1066 verify(mockPolicyRestController, atLeast(1)).deleteElasticData(any(String.class));
1067 verify(mockPolicyController, atLeast(1)).deleteData(mockPolicyEntity);
1071 public void test28Delete() throws Exception {
1072 JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
1073 HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
1074 User mockUser = Mockito.mock(User.class);
1075 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1076 List<Object> policyEntityList = new ArrayList<Object>();
1077 PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
1078 policyEntityList.add(mockPolicyEntity);
1081 PolicyManagerServlet servlet = new PolicyManagerServlet() {
1082 private static final long serialVersionUID = 1L;
1085 protected User getUserSession(HttpServletRequest request) {
1090 PolicyManagerServlet.setPolicyController(mockPolicyController);
1091 when(mockUser.getOrgUserId()).thenReturn("sampleUserId");
1092 when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.1.xml");
1093 when(mockJSONObject.has("deleteVersion")).thenReturn(true);
1094 when(mockJSONObject.getString("deleteVersion")).thenReturn("ALL");
1095 when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1096 .thenReturn(policyEntityList);
1097 when(mockPolicyEntity.getPolicyId()).thenReturn(policyId);
1098 when(mockPolicyEntity.getScope()).thenReturn("sampleScope");
1099 when(mockPolicyEntity.getPolicyName()).thenReturn("samplePolicyName");
1101 JSONObject returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1102 assertTrue(returnObj.has("result"));
1103 verify(mockUser, atLeast(1)).getOrgUserId();
1104 verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1105 verify(mockJSONObject, atLeast(1)).has(any(String.class));
1106 verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1107 verify(mockPolicyEntity, atLeast(1)).getPolicyId();
1108 verify(mockPolicyEntity, atLeast(1)).getScope();
1109 verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1111 when(mockJSONObject.getString("path")).thenReturn("/sampleScope\\:samplePolicyName.1.xml");
1112 when(mockJSONObject.getString("deleteVersion")).thenReturn("CURRENT");
1113 returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1114 assertTrue(returnObj.has("result"));
1115 verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1117 when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.2.txt");
1118 when(mockJSONObject.has("deleteVersion")).thenReturn(false);
1119 returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1120 assertTrue(returnObj.has("result"));
1121 verify(mockJSONObject, atLeast(1)).getString("path");
1122 verify(mockJSONObject, atLeast(1)).has("deleteVersion");
1126 public void test29ParsePolicyList() throws Exception {
1127 PolicyManagerServlet servlet = new PolicyManagerServlet();
1128 List<JSONObject> resultList = new ArrayList<JSONObject>();
1129 PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1130 UserInfo mockUserInfo = Mockito.mock(UserInfo.class);
1131 String policyName = "sampleName\\";
1132 String policyVersion = "sampleVersion";
1133 List<Object> activeDataList = new ArrayList<Object>();
1134 PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
1135 activeDataList.add(mockPolicyVersion);
1136 Date mockDate = Mockito.mock(Date.class);
1138 when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1139 .thenReturn(activeDataList);
1140 when(mockPolicyVersion.getPolicyName()).thenReturn("testPolicyName");
1141 when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
1142 when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
1143 when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
1144 when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
1146 // This intermittently throws an NPE, even when fixing the method order
1148 when(mockPolicyController.getEntityItem(UserInfo.class, "userLoginId", "sampleUserName"))
1149 .thenReturn(mockUserInfo);
1150 when(mockUserInfo.getUserName()).thenReturn("testUserName");
1151 Whitebox.invokeMethod(servlet, "parsePolicyList", resultList, mockPolicyController, policyName, policyVersion);
1152 verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1153 verify(mockPolicyVersion, atLeast(1)).getPolicyName();
1154 verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
1155 verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
1156 verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
1157 verify(mockPolicyVersion, atLeast(1)).getModifiedBy();