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;
75 public void setUp() throws Exception {
76 logger.info("setUp: Entering");
78 request = mock(HttpServletRequest.class);
79 response = new MockHttpServletResponse();
81 PolicyController.setjUnit(true);
82 UserInfo userinfo = new UserInfo();
83 userinfo.setUserLoginId("Test");
84 userinfo.setUserName("Test");
86 rolesdata = new ArrayList<>();
87 Roles roles = new Roles();
88 roles.setLoginId("Test");
89 roles.setRole("super-admin");
90 Roles roles1 = new Roles();
92 roles1.setName("Test");
93 assertTrue("Test".equals(roles1.getName()));
94 roles1.setLoginId("Test");
95 roles1.setRole("admin");
96 roles1.setScope("['com','Test']");
98 rolesdata.add(roles1);
101 basePolicyData = new ArrayList<>();
102 String policyContent = "";
104 ClassLoader classLoader = getClass().getClassLoader();
105 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
106 } catch (Exception e1) {
107 logger.error("Exception Occured" + e1);
109 PolicyEntity entity = new PolicyEntity();
110 entity.setPolicyName("Config_SampleTest.1.xml");
111 entity.setPolicyData(policyContent);
112 entity.setScope("com");
113 configurationEntity = new ConfigurationDataEntity();
114 configurationEntity.setConfigBody("Sample Test");
115 configurationEntity.setConfigType("OTHER");
116 configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
117 configurationEntity.setDescription("test");
118 entity.setConfigurationData(configurationEntity);
119 basePolicyData.add(entity);
121 // PolicyEditorScopes data
122 policyEditorScopes = new ArrayList<>();
123 PolicyEditorScopes scopes = new PolicyEditorScopes();
124 scopes.setScopeName("com");
125 scopes.setUserCreatedBy(userinfo);
126 scopes.setUserModifiedBy(userinfo);
127 PolicyEditorScopes scopes1 = new PolicyEditorScopes();
128 scopes1.setScopeName("com\\Test");
129 scopes1.setUserCreatedBy(userinfo);
130 scopes1.setUserModifiedBy(userinfo);
131 policyEditorScopes.add(scopes);
132 policyEditorScopes.add(scopes1);
134 // PolicyVersion data
135 policyVersion = new ArrayList<>();
136 PolicyVersion policy = new PolicyVersion();
137 policy.setPolicyName("com\\Config_SampleTest1206");
138 policy.setActiveVersion(1);
139 policy.setHigherVersion(1);
140 policy.setCreatedBy("Test");
141 policy.setModifiedBy("Test");
142 policyVersion.add(policy);
144 HttpSession mockSession = mock(HttpSession.class);
145 User user = new User();
146 user.setOrgUserId("Test");
147 Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
148 Mockito.when(request.getSession(false)).thenReturn(mockSession);
149 commonClassDao = mock(CommonClassDao.class);
154 public void testInit() {
155 PolicyManagerServlet servlet = new PolicyManagerServlet();
156 ServletConfig servletConfig = mock(ServletConfig.class);
158 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
159 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
160 System.setProperty("xacml.rest.admin.closedLoopJSON",
161 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
162 + "resources" + File.separator + "JSONConfig.json");
163 servlet.init(servletConfig);
165 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
166 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
168 } catch (Exception e1) {
169 logger.error("Exception Occured" + e1);
175 public void testBadInitJson() {
176 PolicyManagerServlet servlet = new PolicyManagerServlet();
177 ServletConfig servletConfig = mock(ServletConfig.class);
179 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
180 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
181 System.setProperty("xacml.rest.admin.closedLoopJSON",
182 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
183 + "resources" + File.separator + "JSONConfig.foo");
184 servlet.init(servletConfig);
185 } catch (Exception e1) {
186 logger.error("Exception Occured" + e1);
192 public void testBadInitJsonInvalidFile() {
193 PolicyManagerServlet servlet = new PolicyManagerServlet();
194 ServletConfig servletConfig = mock(ServletConfig.class);
196 when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
197 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
198 System.setProperty("xacml.rest.admin.closedLoopJSON",
199 new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
200 + "resources" + File.separator + "IDonotExist.json");
201 servlet.init(servletConfig);
202 } catch (Exception e1) {
203 logger.error("Exception Occured" + e1);
208 @SuppressWarnings("static-access")
210 public void testDescribePolicy() {
211 PolicyManagerServlet servlet = new PolicyManagerServlet();
212 PolicyController controller = mock(PolicyController.class);
213 BufferedReader reader = new BufferedReader(
214 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
216 when(request.getReader()).thenReturn(reader);
217 String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
218 when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
219 servlet.setPolicyController(controller);
220 servlet.doPost(request, response);
221 } catch (Exception e1) {
222 logger.error("Exception Occured" + e1);
227 @SuppressWarnings("static-access")
229 public void testPolicyScopeList() {
230 PolicyManagerServlet servlet = new PolicyManagerServlet();
231 PolicyController controller = mock(PolicyController.class);
232 List<String> list = new ArrayList<>();
233 list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
234 list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
235 for (int i = 0; i < list.size(); i++) {
236 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
238 when(request.getReader()).thenReturn(reader);
239 when(controller.getRoles("Test")).thenReturn(rolesdata);
240 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
241 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
242 .thenReturn(policyEditorScopes);
243 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
244 .thenReturn(policyVersion);
245 servlet.setPolicyController(controller);
246 servlet.setTestUserId("Test");
247 servlet.doPost(request, response);
248 } catch (Exception e1) {
249 logger.error("Exception Occured" + e1);
255 @SuppressWarnings("static-access")
257 public void editBasePolicyTest() {
258 PolicyManagerServlet servlet = new PolicyManagerServlet();
259 PolicyController controller = mock(PolicyController.class);
260 List<String> list = new ArrayList<>();
261 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
262 for (int i = 0; i < list.size(); i++) {
263 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
265 when(request.getReader()).thenReturn(reader);
266 when(controller.getRoles("Test")).thenReturn(rolesdata);
267 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
268 null)).thenReturn(basePolicyData);
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 editBRMSParamPolicyTest() {
282 List<Object> policyData = new ArrayList<>();
283 String policyContent = "";
284 String configData = "";
286 ClassLoader classLoader = getClass().getClassLoader();
288 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
290 .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
291 } catch (Exception e1) {
292 logger.error("Exception Occured" + e1);
294 PolicyEntity entity = new PolicyEntity();
295 entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
296 entity.setPolicyData(policyContent);
297 entity.setScope("com");
298 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
299 configurationEntity.setConfigBody(configData);
300 configurationEntity.setConfigType("OTHER");
301 configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
302 configurationEntity.setDescription("test");
303 entity.setConfigurationData(configurationEntity);
304 policyData.add(entity);
305 PolicyManagerServlet servlet = new PolicyManagerServlet();
306 PolicyController controller = mock(PolicyController.class);
307 List<String> list = new ArrayList<>();
308 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
309 + " onlyFolders: false}}");
310 for (int i = 0; i < list.size(); i++) {
311 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
313 when(request.getReader()).thenReturn(reader);
314 when(controller.getRoles("Test")).thenReturn(rolesdata);
315 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
316 null)).thenReturn(policyData);
317 servlet.setPolicyController(controller);
318 servlet.setTestUserId("Test");
319 servlet.doPost(request, response);
320 } catch (Exception e1) {
321 logger.error("Exception Occured" + e1);
327 @SuppressWarnings("static-access")
329 public void editBRMSRawPolicyTest() {
330 List<Object> policyData = new ArrayList<>();
331 String policyContent = "";
332 String configData = "";
334 ClassLoader classLoader = getClass().getClassLoader();
336 IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
338 IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
339 } catch (Exception e1) {
340 logger.error("Exception Occured" + e1);
342 PolicyEntity entity = new PolicyEntity();
343 entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
344 entity.setPolicyData(policyContent);
345 entity.setScope("com");
346 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
347 configurationEntity.setConfigBody(configData);
348 configurationEntity.setConfigType("OTHER");
349 configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
350 configurationEntity.setDescription("test");
351 entity.setConfigurationData(configurationEntity);
352 policyData.add(entity);
353 PolicyManagerServlet servlet = new PolicyManagerServlet();
354 PolicyController controller = mock(PolicyController.class);
355 List<String> list = new ArrayList<>();
356 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
357 + " onlyFolders: false}}");
358 for (int i = 0; i < list.size(); i++) {
359 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
361 when(request.getReader()).thenReturn(reader);
362 when(controller.getRoles("Test")).thenReturn(rolesdata);
363 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
364 null)).thenReturn(policyData);
365 servlet.setPolicyController(controller);
366 servlet.setTestUserId("Test");
367 servlet.doPost(request, response);
368 } catch (Exception e1) {
369 logger.error("Exception Occured" + e1);
375 @SuppressWarnings("static-access")
377 public void editClosedLoopFaultPolicyTest() {
378 List<Object> policyData = new ArrayList<>();
379 String policyContent = "";
380 String configData = "";
382 ClassLoader classLoader = getClass().getClassLoader();
384 IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
386 IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
387 } catch (Exception e1) {
388 logger.error("Exception Occured" + e1);
390 PolicyEntity entity = new PolicyEntity();
391 entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
392 entity.setPolicyData(policyContent);
393 entity.setScope("com");
394 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
395 configurationEntity.setConfigBody(configData);
396 configurationEntity.setConfigType("JSON");
397 configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
398 configurationEntity.setDescription("test");
399 entity.setConfigurationData(configurationEntity);
400 policyData.add(entity);
401 PolicyManagerServlet servlet = new PolicyManagerServlet();
402 PolicyController controller = mock(PolicyController.class);
403 List<String> list = new ArrayList<>();
404 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
405 + " onlyFolders: false}}");
406 for (int i = 0; i < list.size(); i++) {
407 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
409 when(request.getReader()).thenReturn(reader);
410 when(controller.getRoles("Test")).thenReturn(rolesdata);
411 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
412 null)).thenReturn(policyData);
413 servlet.setPolicyController(controller);
414 servlet.setTestUserId("Test");
415 servlet.doPost(request, response);
416 } catch (Exception e1) {
417 logger.error("Exception Occured" + e1);
423 @SuppressWarnings("static-access")
425 public void editClosedLoopPMPolicyTest() {
426 List<Object> policyData = new ArrayList<>();
427 String policyContent = "";
428 String configData = "";
430 ClassLoader classLoader = getClass().getClassLoader();
431 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
433 IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
434 } catch (Exception e1) {
435 logger.error("Exception Occured" + e1);
437 PolicyEntity entity = new PolicyEntity();
438 entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
439 entity.setPolicyData(policyContent);
440 entity.setScope("com");
441 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
442 configurationEntity.setConfigBody(configData);
443 configurationEntity.setConfigType("JSON");
444 configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
445 configurationEntity.setDescription("test");
446 entity.setConfigurationData(configurationEntity);
447 policyData.add(entity);
448 PolicyManagerServlet servlet = new PolicyManagerServlet();
449 PolicyController controller = mock(PolicyController.class);
450 List<String> list = new ArrayList<>();
451 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
452 + " onlyFolders: false}}");
453 for (int i = 0; i < list.size(); i++) {
454 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
456 when(request.getReader()).thenReturn(reader);
457 when(controller.getRoles("Test")).thenReturn(rolesdata);
458 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
459 null)).thenReturn(policyData);
460 servlet.setPolicyController(controller);
461 servlet.setTestUserId("Test");
462 servlet.doPost(request, response);
463 } catch (Exception e1) {
464 logger.error("Exception Occured" + e1);
470 @SuppressWarnings("static-access")
472 public void editMicroServicePolicyTest() {
473 GroupPolicyScopeList groupData = new GroupPolicyScopeList();
474 groupData.setGroupName("Test");
475 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
476 + "closedLoopControlName=SampleClosedLoop");
477 List<Object> groupListData = new ArrayList<>();
478 groupListData.add(groupData);
479 commonClassDao = mock(CommonClassDao.class);
480 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
481 List<Object> policyData = new ArrayList<>();
482 String policyContent = "";
483 String configData = "";
485 ClassLoader classLoader = getClass().getClassLoader();
486 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
487 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
488 } catch (Exception e1) {
489 logger.error("Exception Occured" + e1);
491 PolicyEntity entity = new PolicyEntity();
492 entity.setPolicyName("Config_MS_vFirewall.1.xml");
493 entity.setPolicyData(policyContent);
494 entity.setScope("com");
495 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
496 configurationEntity.setConfigBody(configData);
497 configurationEntity.setConfigType("JSON");
498 configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
499 configurationEntity.setDescription("test");
500 entity.setConfigurationData(configurationEntity);
501 policyData.add(entity);
502 PolicyManagerServlet servlet = new PolicyManagerServlet();
503 PolicyController controller = mock(PolicyController.class);
504 List<String> list = new ArrayList<>();
505 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
506 for (int i = 0; i < list.size(); i++) {
507 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
509 when(request.getReader()).thenReturn(reader);
510 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
511 "resource=SampleResource,service=SampleService,type=SampleType,"
512 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
513 when(controller.getRoles("Test")).thenReturn(rolesdata);
514 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
515 null)).thenReturn(policyData);
516 servlet.setPolicyController(controller);
517 servlet.setTestUserId("Test");
518 servlet.doPost(request, response);
519 } catch (Exception e1) {
520 logger.error("Exception Occured" + e1);
526 @SuppressWarnings("static-access")
528 public void editFirewallPolicyTest() {
529 List<Object> policyData = new ArrayList<>();
530 String policyContent = "";
531 String configData = "";
533 ClassLoader classLoader = getClass().getClassLoader();
534 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
535 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
536 } catch (Exception e1) {
537 logger.error("Exception Occured" + e1);
539 PolicyEntity entity = new PolicyEntity();
540 entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
541 entity.setPolicyData(policyContent);
542 entity.setScope("com");
543 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
544 configurationEntity.setConfigBody(configData);
545 configurationEntity.setConfigType("JSON");
546 configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
547 configurationEntity.setDescription("test");
548 entity.setConfigurationData(configurationEntity);
549 policyData.add(entity);
550 PolicyManagerServlet servlet = new PolicyManagerServlet();
551 PolicyController controller = mock(PolicyController.class);
552 List<String> list = new ArrayList<>();
553 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
554 + " onlyFolders: false}}");
555 for (int i = 0; i < list.size(); i++) {
556 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
558 when(request.getReader()).thenReturn(reader);
559 when(controller.getRoles("Test")).thenReturn(rolesdata);
560 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
561 null)).thenReturn(policyData);
562 servlet.setPolicyController(controller);
563 servlet.setTestUserId("Test");
564 servlet.doPost(request, response);
565 } catch (Exception e1) {
566 logger.error("Exception Occured" + e1);
572 @SuppressWarnings("static-access")
574 public void editActionPolicyTest() {
575 List<Object> policyData = new ArrayList<>();
576 String policyContent = "";
577 String configData = "";
579 ClassLoader classLoader = getClass().getClassLoader();
580 policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
581 configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
582 } catch (Exception e1) {
583 logger.error("Exception Occured" + e1);
585 PolicyEntity entity = new PolicyEntity();
586 entity.setPolicyName("Action_TestActionPolicy.1.xml");
587 entity.setPolicyData(policyContent);
588 entity.setScope("com");
589 ActionBodyEntity configurationEntity = new ActionBodyEntity();
590 configurationEntity.setActionBody(configData);
591 configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
592 entity.setActionBodyEntity(configurationEntity);
593 policyData.add(entity);
594 PolicyManagerServlet servlet = new PolicyManagerServlet();
595 PolicyController controller = mock(PolicyController.class);
596 List<String> list = new ArrayList<>();
597 list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
598 for (int i = 0; i < list.size(); i++) {
599 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
601 when(request.getReader()).thenReturn(reader);
602 when(controller.getRoles("Test")).thenReturn(rolesdata);
603 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
604 null)).thenReturn(policyData);
605 servlet.setPolicyController(controller);
606 servlet.setTestUserId("Test");
607 servlet.doPost(request, response);
608 } catch (Exception e1) {
609 logger.error("Exception Occured" + e1);
615 @SuppressWarnings("static-access")
617 public void editDecisionPolicyTest() {
618 List<Object> policyData = new ArrayList<>();
619 String policyContent = "";
621 ClassLoader classLoader = getClass().getClassLoader();
622 policyContent = IOUtils
623 .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
624 } catch (Exception e1) {
625 logger.error("Exception Occured" + e1);
627 PolicyEntity entity = new PolicyEntity();
628 entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
629 entity.setPolicyData(policyContent);
630 entity.setScope("com");
631 policyData.add(entity);
632 PolicyManagerServlet servlet = new PolicyManagerServlet();
633 PolicyController controller = mock(PolicyController.class);
634 List<String> list = new ArrayList<>();
635 list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
636 + " onlyFolders: false}}");
637 for (int i = 0; i < list.size(); i++) {
638 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
640 when(request.getReader()).thenReturn(reader);
641 when(controller.getRoles("Test")).thenReturn(rolesdata);
642 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
643 null)).thenReturn(policyData);
644 servlet.setPolicyController(controller);
645 servlet.setTestUserId("Test");
646 servlet.doPost(request, response);
647 } catch (Exception e1) {
648 logger.error("Exception Occured" + e1);
655 public void testAddScope() {
656 PolicyManagerServlet servlet = new PolicyManagerServlet();
657 PolicyController controller = mock(PolicyController.class);
658 List<BufferedReader> readers = new ArrayList<>();
659 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
660 readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
661 readers.add(new BufferedReader(
662 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
663 for (int i = 0; i < readers.size(); i++) {
665 when(request.getReader()).thenReturn(readers.get(i));
666 PolicyManagerServlet.setPolicyController(controller);
667 servlet.doPost(request, response);
668 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
669 } catch (Exception e1) {
670 logger.error("Exception Occured" + e1);
677 public void testClone() {
678 PolicyManagerServlet servlet = new PolicyManagerServlet();
679 PolicyController controller = mock(PolicyController.class);
680 List<BufferedReader> readers = new ArrayList<>();
681 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
682 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
683 when(controller.getDataByQuery(
684 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
685 .thenReturn(basePolicyData);
686 readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
687 + " newPath: 'com.Config_testClone.1.xml'}}")));
688 for (int i = 0; i < readers.size(); i++) {
690 when(request.getReader()).thenReturn(readers.get(i));
691 PolicyManagerServlet.setPolicyController(controller);
692 servlet.doPost(request, response);
693 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
694 } catch (Exception e1) {
695 logger.error("Exception Occured" + e1);
702 public void testRename() {
703 PolicyManagerServlet servlet = new PolicyManagerServlet();
704 PolicyController controller = mock(PolicyController.class);
705 List<BufferedReader> readers = new ArrayList<>();
706 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
707 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
708 when(controller.getDataByQuery(
709 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
710 .thenReturn(basePolicyData);
711 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
712 + " newPath: 'com.Config_testClone.1.xml'}}")));
713 for (int i = 0; i < readers.size(); i++) {
715 when(request.getReader()).thenReturn(readers.get(i));
716 PolicyManagerServlet.setPolicyController(controller);
717 servlet.doPost(request, response);
718 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
719 } catch (Exception e1) {
720 logger.error("Exception Occured" + e1);
727 public void testRenameScope() {
728 PolicyManagerServlet servlet = new PolicyManagerServlet();
729 PolicyController controller = mock(PolicyController.class);
730 List<BufferedReader> readers = new ArrayList<>();
731 readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
732 for (int i = 0; i < readers.size(); i++) {
734 when(request.getReader()).thenReturn(readers.get(i));
735 PolicyManagerServlet.setPolicyController(controller);
736 servlet.doPost(request, response);
737 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
738 } catch (Exception e1) {
739 logger.error("Exception Occured" + e1);