2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Modifications Copyright (C) 2019 Samsung
8 * ================================================================================
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 * ============LICENSE_END=========================================================
23 package org.onap.policy.admin;
25 import static org.junit.Assert.assertTrue;
26 import static org.junit.Assert.fail;
28 import java.io.BufferedReader;
30 import java.io.StringReader;
31 import java.util.ArrayList;
32 import java.util.Collections;
33 import java.util.List;
35 import javax.servlet.ServletConfig;
36 import javax.servlet.http.HttpServletRequest;
37 import javax.servlet.http.HttpSession;
39 import org.apache.commons.io.IOUtils;
40 import org.junit.Before;
41 import org.junit.Test;
42 import org.mockito.Mockito;
43 import org.onap.policy.common.logging.flexlogger.FlexLogger;
44 import org.onap.policy.common.logging.flexlogger.Logger;
45 import org.onap.policy.controller.CreateDcaeMicroServiceController;
46 import org.onap.policy.controller.PolicyController;
47 import org.onap.policy.model.Roles;
48 import org.onap.policy.rest.dao.CommonClassDao;
49 import org.onap.policy.rest.jpa.ActionBodyEntity;
50 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
51 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
52 import org.onap.policy.rest.jpa.PolicyEditorScopes;
53 import org.onap.policy.rest.jpa.PolicyEntity;
54 import org.onap.policy.rest.jpa.PolicyVersion;
55 import org.onap.policy.rest.jpa.UserInfo;
56 import org.onap.portalsdk.core.domain.User;
57 import org.onap.portalsdk.core.util.SystemProperties;
58 import org.springframework.mock.web.MockHttpServletResponse;
60 public class PolicyManagerServletTest extends Mockito {
62 private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
63 private List<String> headers = new ArrayList<String>();
65 private static List<Object> rolesdata;
66 private static List<Object> basePolicyData;
67 private static List<Object> policyEditorScopes;
68 private static List<Object> policyVersion;
69 private static CommonClassDao commonClassDao;
70 private ConfigurationDataEntity configurationEntity;
71 private HttpServletRequest request;
72 private MockHttpServletResponse response;
77 * @throws Exception should not get one
80 public void setUp() throws Exception {
81 logger.info("setUp: Entering");
83 request = mock(HttpServletRequest.class);
84 response = new MockHttpServletResponse();
86 PolicyController.setjUnit(true);
87 UserInfo userinfo = new UserInfo();
88 userinfo.setUserLoginId("Test");
89 userinfo.setUserName("Test");
91 rolesdata = new ArrayList<>();
92 Roles roles = new Roles();
93 roles.setLoginId("Test");
94 roles.setRole("super-admin");
95 Roles roles1 = new Roles();
97 roles1.setName("Test");
98 assertTrue("Test".equals(roles1.getName()));
99 roles1.setLoginId("Test");
100 roles1.setRole("admin");
101 roles1.setScope("['com','Test']");
102 rolesdata.add(roles);
103 rolesdata.add(roles1);
106 basePolicyData = new ArrayList<>();
107 String policyContent = "";
109 ClassLoader classLoader = getClass().getClassLoader();
110 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
111 } catch (Exception e1) {
112 logger.error("Exception Occured" + e1);
114 PolicyEntity entity = new PolicyEntity();
115 entity.setPolicyName("Config_SampleTest.1.xml");
116 entity.setPolicyData(policyContent);
117 entity.setScope("com");
118 configurationEntity = new ConfigurationDataEntity();
119 configurationEntity.setConfigBody("Sample Test");
120 configurationEntity.setConfigType("OTHER");
121 configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
122 configurationEntity.setDescription("test");
123 entity.setConfigurationData(configurationEntity);
124 basePolicyData.add(entity);
126 // PolicyEditorScopes data
127 policyEditorScopes = new ArrayList<>();
128 PolicyEditorScopes scopes = new PolicyEditorScopes();
129 scopes.setScopeName("com");
130 scopes.setUserCreatedBy(userinfo);
131 scopes.setUserModifiedBy(userinfo);
132 PolicyEditorScopes scopes1 = new PolicyEditorScopes();
133 scopes1.setScopeName("com\\Test");
134 scopes1.setUserCreatedBy(userinfo);
135 scopes1.setUserModifiedBy(userinfo);
136 policyEditorScopes.add(scopes);
137 policyEditorScopes.add(scopes1);
139 // PolicyVersion data
140 policyVersion = new ArrayList<>();
141 PolicyVersion policy = new PolicyVersion();
142 policy.setPolicyName("com\\Config_SampleTest1206");
143 policy.setActiveVersion(1);
144 policy.setHigherVersion(1);
145 policy.setCreatedBy("Test");
146 policy.setModifiedBy("Test");
147 policyVersion.add(policy);
149 HttpSession mockSession = mock(HttpSession.class);
150 User user = new User();
151 user.setOrgUserId("Test");
152 Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
153 Mockito.when(request.getSession(false)).thenReturn(mockSession);
154 commonClassDao = mock(CommonClassDao.class);
159 public void testInit() {
160 PolicyManagerServlet servlet = new PolicyManagerServlet();
161 ServletConfig servletConfig = mock(ServletConfig.class);
163 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
164 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
165 System.setProperty("xacml.rest.admin.closedLoopJSON",
166 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
167 + "resources" + File.separator + "JSONConfig.json");
168 servlet.init(servletConfig);
170 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
171 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
173 } catch (Exception e1) {
174 logger.error("Exception Occured" + e1);
180 public void testBadInitJson() {
181 PolicyManagerServlet servlet = new PolicyManagerServlet();
182 ServletConfig servletConfig = mock(ServletConfig.class);
184 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
185 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
186 System.setProperty("xacml.rest.admin.closedLoopJSON",
187 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
188 + "resources" + File.separator + "JSONConfig.foo");
189 servlet.init(servletConfig);
190 } catch (Exception e1) {
191 logger.error("Exception Occured" + e1);
197 public void testBadInitJsonInvalidFile() {
198 PolicyManagerServlet servlet = new PolicyManagerServlet();
199 ServletConfig servletConfig = mock(ServletConfig.class);
201 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
202 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
203 System.setProperty("xacml.rest.admin.closedLoopJSON",
204 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
205 + "resources" + File.separator + "IDonotExist.json");
206 servlet.init(servletConfig);
207 } catch (Exception e1) {
208 logger.error("Exception Occured" + e1);
213 @SuppressWarnings("static-access")
215 public void testDescribePolicy() {
216 PolicyManagerServlet servlet = new PolicyManagerServlet();
217 PolicyController controller = mock(PolicyController.class);
218 BufferedReader reader = new BufferedReader(
219 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
221 when(request.getReader()).thenReturn(reader);
222 String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
223 when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
224 servlet.setPolicyController(controller);
225 servlet.doPost(request, response);
226 } catch (Exception e1) {
227 logger.error("Exception Occured" + e1);
232 @SuppressWarnings("static-access")
234 public void testPolicyScopeList() {
235 PolicyManagerServlet servlet = new PolicyManagerServlet();
236 PolicyController controller = mock(PolicyController.class);
237 List<String> list = new ArrayList<>();
238 list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
239 list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
240 for (int i = 0; i < list.size(); i++) {
241 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
243 when(request.getReader()).thenReturn(reader);
244 when(controller.getRoles("Test")).thenReturn(rolesdata);
245 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
246 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
247 .thenReturn(policyEditorScopes);
248 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
249 .thenReturn(policyVersion);
250 servlet.setPolicyController(controller);
251 servlet.setTestUserId("Test");
252 servlet.doPost(request, response);
253 } catch (Exception e1) {
254 logger.error("Exception Occured" + e1);
260 @SuppressWarnings("static-access")
262 public void editBasePolicyTest() {
263 PolicyManagerServlet servlet = new PolicyManagerServlet();
264 PolicyController controller = mock(PolicyController.class);
265 List<String> list = new ArrayList<>();
266 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
267 for (int i = 0; i < list.size(); i++) {
268 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
270 when(request.getReader()).thenReturn(reader);
271 when(controller.getRoles("Test")).thenReturn(rolesdata);
272 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
273 null)).thenReturn(basePolicyData);
274 servlet.setPolicyController(controller);
275 servlet.setTestUserId("Test");
276 servlet.doPost(request, response);
277 } catch (Exception e1) {
278 logger.error("Exception Occured" + e1);
284 @SuppressWarnings("static-access")
286 public void editBRMSParamPolicyTest() {
287 List<Object> policyData = new ArrayList<>();
288 String policyContent = "";
289 String configData = "";
291 ClassLoader classLoader = getClass().getClassLoader();
293 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
295 .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
296 } catch (Exception e1) {
297 logger.error("Exception Occured" + e1);
299 PolicyEntity entity = new PolicyEntity();
300 entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
301 entity.setPolicyData(policyContent);
302 entity.setScope("com");
303 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
304 configurationEntity.setConfigBody(configData);
305 configurationEntity.setConfigType("OTHER");
306 configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
307 configurationEntity.setDescription("test");
308 entity.setConfigurationData(configurationEntity);
309 policyData.add(entity);
310 PolicyManagerServlet servlet = new PolicyManagerServlet();
311 PolicyController controller = mock(PolicyController.class);
312 List<String> list = new ArrayList<>();
313 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
314 + " onlyFolders: false}}");
315 for (int i = 0; i < list.size(); i++) {
316 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
318 when(request.getReader()).thenReturn(reader);
319 when(controller.getRoles("Test")).thenReturn(rolesdata);
320 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
321 null)).thenReturn(policyData);
322 servlet.setPolicyController(controller);
323 servlet.setTestUserId("Test");
324 servlet.doPost(request, response);
325 } catch (Exception e1) {
326 logger.error("Exception Occured" + e1);
332 @SuppressWarnings("static-access")
334 public void editBRMSRawPolicyTest() {
335 List<Object> policyData = new ArrayList<>();
336 String policyContent = "";
337 String configData = "";
339 ClassLoader classLoader = getClass().getClassLoader();
341 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
343 IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
344 } catch (Exception e1) {
345 logger.error("Exception Occured" + e1);
347 PolicyEntity entity = new PolicyEntity();
348 entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
349 entity.setPolicyData(policyContent);
350 entity.setScope("com");
351 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
352 configurationEntity.setConfigBody(configData);
353 configurationEntity.setConfigType("OTHER");
354 configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
355 configurationEntity.setDescription("test");
356 entity.setConfigurationData(configurationEntity);
357 policyData.add(entity);
358 PolicyManagerServlet servlet = new PolicyManagerServlet();
359 PolicyController controller = mock(PolicyController.class);
360 List<String> list = new ArrayList<>();
361 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
362 + " onlyFolders: false}}");
363 for (int i = 0; i < list.size(); i++) {
364 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
366 when(request.getReader()).thenReturn(reader);
367 when(controller.getRoles("Test")).thenReturn(rolesdata);
368 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
369 null)).thenReturn(policyData);
370 servlet.setPolicyController(controller);
371 servlet.setTestUserId("Test");
372 servlet.doPost(request, response);
373 } catch (Exception e1) {
374 logger.error("Exception Occured" + e1);
380 @SuppressWarnings("static-access")
382 public void editClosedLoopFaultPolicyTest() {
383 List<Object> policyData = new ArrayList<>();
384 String policyContent = "";
385 String configData = "";
387 ClassLoader classLoader = getClass().getClassLoader();
389 IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
391 IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
392 } catch (Exception e1) {
393 logger.error("Exception Occured" + e1);
395 PolicyEntity entity = new PolicyEntity();
396 entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
397 entity.setPolicyData(policyContent);
398 entity.setScope("com");
399 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
400 configurationEntity.setConfigBody(configData);
401 configurationEntity.setConfigType("JSON");
402 configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
403 configurationEntity.setDescription("test");
404 entity.setConfigurationData(configurationEntity);
405 policyData.add(entity);
406 PolicyManagerServlet servlet = new PolicyManagerServlet();
407 PolicyController controller = mock(PolicyController.class);
408 List<String> list = new ArrayList<>();
409 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
410 + " onlyFolders: false}}");
411 for (int i = 0; i < list.size(); i++) {
412 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
414 when(request.getReader()).thenReturn(reader);
415 when(controller.getRoles("Test")).thenReturn(rolesdata);
416 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
417 null)).thenReturn(policyData);
418 servlet.setPolicyController(controller);
419 servlet.setTestUserId("Test");
420 servlet.doPost(request, response);
421 } catch (Exception e1) {
422 logger.error("Exception Occured" + e1);
428 @SuppressWarnings("static-access")
430 public void editClosedLoopPMPolicyTest() {
431 List<Object> policyData = new ArrayList<>();
432 String policyContent = "";
433 String configData = "";
435 ClassLoader classLoader = getClass().getClassLoader();
436 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
438 IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
439 } catch (Exception e1) {
440 logger.error("Exception Occured" + e1);
442 PolicyEntity entity = new PolicyEntity();
443 entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
444 entity.setPolicyData(policyContent);
445 entity.setScope("com");
446 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
447 configurationEntity.setConfigBody(configData);
448 configurationEntity.setConfigType("JSON");
449 configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
450 configurationEntity.setDescription("test");
451 entity.setConfigurationData(configurationEntity);
452 policyData.add(entity);
453 PolicyManagerServlet servlet = new PolicyManagerServlet();
454 PolicyController controller = mock(PolicyController.class);
455 List<String> list = new ArrayList<>();
456 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
457 + " onlyFolders: false}}");
458 for (int i = 0; i < list.size(); i++) {
459 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
461 when(request.getReader()).thenReturn(reader);
462 when(controller.getRoles("Test")).thenReturn(rolesdata);
463 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
464 null)).thenReturn(policyData);
465 servlet.setPolicyController(controller);
466 servlet.setTestUserId("Test");
467 servlet.doPost(request, response);
468 } catch (Exception e1) {
469 logger.error("Exception Occured" + e1);
475 @SuppressWarnings("static-access")
477 public void editMicroServicePolicyTest() {
478 GroupPolicyScopeList groupData = new GroupPolicyScopeList();
479 groupData.setGroupName("Test");
480 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
481 + "closedLoopControlName=SampleClosedLoop");
482 List<Object> groupListData = new ArrayList<>();
483 groupListData.add(groupData);
484 commonClassDao = mock(CommonClassDao.class);
485 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
486 List<Object> policyData = new ArrayList<>();
487 String policyContent = "";
488 String configData = "";
490 ClassLoader classLoader = getClass().getClassLoader();
491 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
492 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
493 } catch (Exception e1) {
494 logger.error("Exception Occured" + e1);
496 PolicyEntity entity = new PolicyEntity();
497 entity.setPolicyName("Config_MS_vFirewall.1.xml");
498 entity.setPolicyData(policyContent);
499 entity.setScope("com");
500 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
501 configurationEntity.setConfigBody(configData);
502 configurationEntity.setConfigType("JSON");
503 configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
504 configurationEntity.setDescription("test");
505 entity.setConfigurationData(configurationEntity);
506 policyData.add(entity);
507 PolicyManagerServlet servlet = new PolicyManagerServlet();
508 PolicyController controller = mock(PolicyController.class);
509 List<String> list = new ArrayList<>();
510 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
511 for (int i = 0; i < list.size(); i++) {
512 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
514 when(request.getReader()).thenReturn(reader);
515 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
516 "resource=SampleResource,service=SampleService,type=SampleType,"
517 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
518 when(controller.getRoles("Test")).thenReturn(rolesdata);
519 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
520 null)).thenReturn(policyData);
521 servlet.setPolicyController(controller);
522 servlet.setTestUserId("Test");
523 servlet.doPost(request, response);
524 } catch (Exception e1) {
525 logger.error("Exception Occured" + e1);
531 @SuppressWarnings("static-access")
533 public void editFirewallPolicyTest() {
534 List<Object> policyData = new ArrayList<>();
535 String policyContent = "";
536 String configData = "";
538 ClassLoader classLoader = getClass().getClassLoader();
539 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
540 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
541 } catch (Exception e1) {
542 logger.error("Exception Occured" + e1);
544 PolicyEntity entity = new PolicyEntity();
545 entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
546 entity.setPolicyData(policyContent);
547 entity.setScope("com");
548 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
549 configurationEntity.setConfigBody(configData);
550 configurationEntity.setConfigType("JSON");
551 configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
552 configurationEntity.setDescription("test");
553 entity.setConfigurationData(configurationEntity);
554 policyData.add(entity);
555 PolicyManagerServlet servlet = new PolicyManagerServlet();
556 PolicyController controller = mock(PolicyController.class);
557 List<String> list = new ArrayList<>();
558 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
559 + " onlyFolders: false}}");
560 for (int i = 0; i < list.size(); i++) {
561 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
563 when(request.getReader()).thenReturn(reader);
564 when(controller.getRoles("Test")).thenReturn(rolesdata);
565 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
566 null)).thenReturn(policyData);
567 servlet.setPolicyController(controller);
568 servlet.setTestUserId("Test");
569 servlet.doPost(request, response);
570 } catch (Exception e1) {
571 logger.error("Exception Occured" + e1);
577 @SuppressWarnings("static-access")
579 public void editActionPolicyTest() {
580 List<Object> policyData = new ArrayList<>();
581 String policyContent = "";
582 String configData = "";
584 ClassLoader classLoader = getClass().getClassLoader();
585 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
586 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
587 } catch (Exception e1) {
588 logger.error("Exception Occured" + e1);
590 PolicyEntity entity = new PolicyEntity();
591 entity.setPolicyName("Action_TestActionPolicy.1.xml");
592 entity.setPolicyData(policyContent);
593 entity.setScope("com");
594 ActionBodyEntity configurationEntity = new ActionBodyEntity();
595 configurationEntity.setActionBody(configData);
596 configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
597 entity.setActionBodyEntity(configurationEntity);
598 policyData.add(entity);
599 PolicyManagerServlet servlet = new PolicyManagerServlet();
600 PolicyController controller = mock(PolicyController.class);
601 List<String> list = new ArrayList<>();
602 list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
603 for (int i = 0; i < list.size(); i++) {
604 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
606 when(request.getReader()).thenReturn(reader);
607 when(controller.getRoles("Test")).thenReturn(rolesdata);
608 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
609 null)).thenReturn(policyData);
610 servlet.setPolicyController(controller);
611 servlet.setTestUserId("Test");
612 servlet.doPost(request, response);
613 } catch (Exception e1) {
614 logger.error("Exception Occured" + e1);
620 @SuppressWarnings("static-access")
622 public void editDecisionPolicyTest() {
623 List<Object> policyData = new ArrayList<>();
624 String policyContent = "";
626 ClassLoader classLoader = getClass().getClassLoader();
627 policyContent = IOUtils
628 .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
629 } catch (Exception e1) {
630 logger.error("Exception Occured" + e1);
632 PolicyEntity entity = new PolicyEntity();
633 entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
634 entity.setPolicyData(policyContent);
635 entity.setScope("com");
636 policyData.add(entity);
637 PolicyManagerServlet servlet = new PolicyManagerServlet();
638 PolicyController controller = mock(PolicyController.class);
639 List<String> list = new ArrayList<>();
640 list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
641 + " onlyFolders: false}}");
642 for (int i = 0; i < list.size(); i++) {
643 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
645 when(request.getReader()).thenReturn(reader);
646 when(controller.getRoles("Test")).thenReturn(rolesdata);
647 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
648 null)).thenReturn(policyData);
649 servlet.setPolicyController(controller);
650 servlet.setTestUserId("Test");
651 servlet.doPost(request, response);
652 } catch (Exception e1) {
653 logger.error("Exception Occured" + e1);
660 public void testAddScope() {
661 PolicyManagerServlet servlet = new PolicyManagerServlet();
662 PolicyController controller = mock(PolicyController.class);
663 List<BufferedReader> readers = new ArrayList<>();
664 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
665 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
666 readers.add(new BufferedReader(
667 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
668 for (int i = 0; i < readers.size(); i++) {
670 when(request.getReader()).thenReturn(readers.get(i));
671 PolicyManagerServlet.setPolicyController(controller);
672 servlet.doPost(request, response);
673 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
674 } catch (Exception e1) {
675 logger.error("Exception Occured" + e1);
682 public void testClone() {
683 PolicyManagerServlet servlet = new PolicyManagerServlet();
684 PolicyController controller = mock(PolicyController.class);
685 List<BufferedReader> readers = new ArrayList<>();
686 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
687 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
688 when(controller.getDataByQuery(
689 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
690 .thenReturn(basePolicyData);
691 readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
692 + " newPath: 'com.Config_testClone.1.xml'}}")));
693 for (int i = 0; i < readers.size(); i++) {
695 when(request.getReader()).thenReturn(readers.get(i));
696 PolicyManagerServlet.setPolicyController(controller);
697 servlet.doPost(request, response);
698 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
699 } catch (Exception e1) {
700 logger.error("Exception Occured" + e1);
707 public void testRename() {
708 PolicyManagerServlet servlet = new PolicyManagerServlet();
709 PolicyController controller = mock(PolicyController.class);
710 List<BufferedReader> readers = new ArrayList<>();
711 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
712 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
713 when(controller.getDataByQuery(
714 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
715 .thenReturn(basePolicyData);
716 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
717 + " newPath: 'com.Config_testClone.1.xml'}}")));
718 for (int i = 0; i < readers.size(); i++) {
720 when(request.getReader()).thenReturn(readers.get(i));
721 PolicyManagerServlet.setPolicyController(controller);
722 servlet.doPost(request, response);
723 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
724 } catch (Exception e1) {
725 logger.error("Exception Occured" + e1);
732 public void testRenameScope() {
733 PolicyManagerServlet servlet = new PolicyManagerServlet();
734 PolicyController controller = mock(PolicyController.class);
735 List<BufferedReader> readers = new ArrayList<>();
736 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
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);