2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2018 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=========================================================
22 package org.onap.policy.admin;
24 import static org.junit.Assert.assertTrue;
25 import static org.junit.Assert.fail;
26 import java.io.BufferedReader;
28 import java.io.StringReader;
29 import java.util.ArrayList;
30 import java.util.Collections;
31 import java.util.List;
32 import javax.servlet.ServletConfig;
33 import javax.servlet.http.HttpServletRequest;
34 import javax.servlet.http.HttpSession;
35 import org.apache.commons.io.IOUtils;
36 import org.junit.Before;
37 import org.junit.Test;
38 import org.mockito.Mockito;
39 import org.onap.policy.common.logging.flexlogger.FlexLogger;
40 import org.onap.policy.common.logging.flexlogger.Logger;
41 import org.onap.policy.controller.CreateDcaeMicroServiceController;
42 import org.onap.policy.controller.PolicyController;
43 import org.onap.policy.model.Roles;
44 import org.onap.policy.rest.dao.CommonClassDao;
45 import org.onap.policy.rest.jpa.ActionBodyEntity;
46 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
47 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
48 import org.onap.policy.rest.jpa.PolicyEditorScopes;
49 import org.onap.policy.rest.jpa.PolicyEntity;
50 import org.onap.policy.rest.jpa.PolicyVersion;
51 import org.onap.policy.rest.jpa.UserInfo;
52 import org.onap.portalsdk.core.domain.User;
53 import org.onap.portalsdk.core.util.SystemProperties;
54 import org.springframework.mock.web.MockHttpServletResponse;
56 public class PolicyManagerServletTest extends Mockito {
58 private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
59 private List<String> headers = new ArrayList<String>();
61 private static List<Object> rolesdata;
62 private static List<Object> basePolicyData;
63 private static List<Object> policyEditorScopes;
64 private static List<Object> policyVersion;
65 private static CommonClassDao commonClassDao;
66 private ConfigurationDataEntity configurationEntity;
67 private HttpServletRequest request;
68 private MockHttpServletResponse response;
71 public void setUp() throws Exception {
72 logger.info("setUp: Entering");
74 request = mock(HttpServletRequest.class);
75 response = new MockHttpServletResponse();
77 PolicyController.setjUnit(true);
78 UserInfo userinfo = new UserInfo();
79 userinfo.setUserLoginId("Test");
80 userinfo.setUserName("Test");
82 rolesdata = new ArrayList<>();
83 Roles roles = new Roles();
84 roles.setLoginId("Test");
85 roles.setRole("super-admin");
86 Roles roles1 = new Roles();
88 roles1.setName("Test");
89 assertTrue("Test".equals(roles1.getName()));
90 roles1.setLoginId("Test");
91 roles1.setRole("admin");
92 roles1.setScope("['com','Test']");
94 rolesdata.add(roles1);
97 basePolicyData = new ArrayList<>();
98 String policyContent = "";
100 ClassLoader classLoader = getClass().getClassLoader();
101 policyContent = IOUtils
102 .toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
103 } catch (Exception e1) {
104 logger.error("Exception Occured" + e1);
106 PolicyEntity entity = new PolicyEntity();
107 entity.setPolicyName("Config_SampleTest.1.xml");
108 entity.setPolicyData(policyContent);
109 entity.setScope("com");
110 configurationEntity = new ConfigurationDataEntity();
111 configurationEntity.setConfigBody("Sample Test");
112 configurationEntity.setConfigType("OTHER");
113 configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
114 configurationEntity.setDescription("test");
115 entity.setConfigurationData(configurationEntity);
116 basePolicyData.add(entity);
118 // PolicyEditorScopes data
119 policyEditorScopes = new ArrayList<>();
120 PolicyEditorScopes scopes = new PolicyEditorScopes();
121 scopes.setScopeName("com");
122 scopes.setUserCreatedBy(userinfo);
123 scopes.setUserModifiedBy(userinfo);
124 PolicyEditorScopes scopes1 = new PolicyEditorScopes();
125 scopes1.setScopeName("com\\Test");
126 scopes1.setUserCreatedBy(userinfo);
127 scopes1.setUserModifiedBy(userinfo);
128 policyEditorScopes.add(scopes);
129 policyEditorScopes.add(scopes1);
131 // PolicyVersion data
132 policyVersion = new ArrayList<>();
133 PolicyVersion policy = new PolicyVersion();
134 policy.setPolicyName("com\\Config_SampleTest1206");
135 policy.setActiveVersion(1);
136 policy.setHigherVersion(1);
137 policy.setCreatedBy("Test");
138 policy.setModifiedBy("Test");
139 policyVersion.add(policy);
141 HttpSession mockSession = mock(HttpSession.class);
142 User user = new User();
143 user.setOrgUserId("Test");
144 Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name")))
146 Mockito.when(request.getSession(false)).thenReturn(mockSession);
147 commonClassDao = mock(CommonClassDao.class);
152 public void testInit() {
153 PolicyManagerServlet servlet = new PolicyManagerServlet();
154 ServletConfig servletConfig = mock(ServletConfig.class);
156 when(servletConfig.getInitParameterNames())
157 .thenReturn(Collections.enumeration(headers));
158 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME"))
159 .thenReturn("xacml.admin.properties");
160 System.setProperty("xacml.rest.admin.closedLoopJSON",
161 new File(".").getCanonicalPath() + File.separator + "src" + File.separator
162 + "test" + File.separator + "resources" + File.separator
163 + "JSONConfig.json");
164 servlet.init(servletConfig);
166 assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
167 assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
169 } catch (Exception e1) {
170 logger.error("Exception Occured" + e1);
176 public void testBadInitJson() {
177 PolicyManagerServlet servlet = new PolicyManagerServlet();
178 ServletConfig servletConfig = mock(ServletConfig.class);
180 when(servletConfig.getInitParameterNames())
181 .thenReturn(Collections.enumeration(headers));
182 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME"))
183 .thenReturn("xacml.admin.properties");
184 System.setProperty("xacml.rest.admin.closedLoopJSON",
185 new File(".").getCanonicalPath() + File.separator + "src" + File.separator
186 + "test" + File.separator + "resources" + File.separator
188 servlet.init(servletConfig);
189 } catch (Exception e1) {
190 logger.error("Exception Occured" + e1);
196 public void testBadInitJsonInvalidFile() {
197 PolicyManagerServlet servlet = new PolicyManagerServlet();
198 ServletConfig servletConfig = mock(ServletConfig.class);
200 when(servletConfig.getInitParameterNames())
201 .thenReturn(Collections.enumeration(headers));
202 when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME"))
203 .thenReturn("xacml.admin.properties");
204 System.setProperty("xacml.rest.admin.closedLoopJSON",
205 new File(".").getCanonicalPath() + File.separator + "src" + File.separator
206 + "test" + File.separator + "resources" + File.separator
207 + "IDonotExist.json");
208 servlet.init(servletConfig);
209 } catch (Exception e1) {
210 logger.error("Exception Occured" + e1);
215 @SuppressWarnings("static-access")
217 public void testDescribePolicy() {
218 PolicyManagerServlet servlet = new PolicyManagerServlet();
219 PolicyController controller = mock(PolicyController.class);
220 BufferedReader reader = new BufferedReader(new StringReader(
221 "{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
223 when(request.getReader()).thenReturn(reader);
224 String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
225 when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
226 servlet.setPolicyController(controller);
227 servlet.doPost(request, response);
228 } catch (Exception e1) {
229 logger.error("Exception Occured" + e1);
235 @SuppressWarnings("static-access")
237 public void testPolicyScopeList() {
238 PolicyManagerServlet servlet = new PolicyManagerServlet();
239 PolicyController controller = mock(PolicyController.class);
240 List<String> list = new ArrayList<>();
241 list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
242 list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
243 for (int i = 0; i < list.size(); i++) {
244 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
246 when(request.getReader()).thenReturn(reader);
247 when(controller.getRoles("Test")).thenReturn(rolesdata);
248 when(controller.getDataByQuery("from PolicyEditorScopes", null))
249 .thenReturn(policyEditorScopes);
250 when(controller.getDataByQuery(
251 "from PolicyEditorScopes where SCOPENAME like :scopeName", null))
252 .thenReturn(policyEditorScopes);
253 when(controller.getDataByQuery(
254 "from PolicyVersion where POLICY_NAME like :scopeName", null))
255 .thenReturn(policyVersion);
256 servlet.setPolicyController(controller);
257 servlet.setTestUserId("Test");
258 servlet.doPost(request, response);
259 } catch (Exception e1) {
260 logger.error("Exception Occured" + e1);
266 @SuppressWarnings("static-access")
268 public void editBasePolicyTest() {
269 PolicyManagerServlet servlet = new PolicyManagerServlet();
270 PolicyController controller = mock(PolicyController.class);
271 List<String> list = new ArrayList<>();
273 "{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
274 for (int i = 0; i < list.size(); i++) {
275 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
277 when(request.getReader()).thenReturn(reader);
278 when(controller.getRoles("Test")).thenReturn(rolesdata);
279 when(controller.getDataByQuery(
280 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
281 .thenReturn(basePolicyData);
282 servlet.setPolicyController(controller);
283 servlet.setTestUserId("Test");
284 servlet.doPost(request, response);
285 } catch (Exception e1) {
286 logger.error("Exception Occured" + e1);
292 @SuppressWarnings("static-access")
294 public void editBRMSParamPolicyTest() {
295 List<Object> policyData = new ArrayList<>();
296 String policyContent = "";
297 String configData = "";
299 ClassLoader classLoader = getClass().getClassLoader();
300 policyContent = IOUtils.toString(classLoader
301 .getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
302 configData = IOUtils.toString(classLoader
303 .getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
304 } catch (Exception e1) {
305 logger.error("Exception Occured" + e1);
307 PolicyEntity entity = new PolicyEntity();
308 entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
309 entity.setPolicyData(policyContent);
310 entity.setScope("com");
311 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
312 configurationEntity.setConfigBody(configData);
313 configurationEntity.setConfigType("OTHER");
315 .setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
316 configurationEntity.setDescription("test");
317 entity.setConfigurationData(configurationEntity);
318 policyData.add(entity);
319 PolicyManagerServlet servlet = new PolicyManagerServlet();
320 PolicyController controller = mock(PolicyController.class);
321 List<String> list = new ArrayList<>();
323 "{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
324 + " onlyFolders: false}}");
325 for (int i = 0; i < list.size(); i++) {
326 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
328 when(request.getReader()).thenReturn(reader);
329 when(controller.getRoles("Test")).thenReturn(rolesdata);
330 when(controller.getDataByQuery(
331 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
332 .thenReturn(policyData);
333 servlet.setPolicyController(controller);
334 servlet.setTestUserId("Test");
335 servlet.doPost(request, response);
336 } catch (Exception e1) {
337 logger.error("Exception Occured" + e1);
343 @SuppressWarnings("static-access")
345 public void editBRMSRawPolicyTest() {
346 List<Object> policyData = new ArrayList<>();
347 String policyContent = "";
348 String configData = "";
350 ClassLoader classLoader = getClass().getClassLoader();
351 policyContent = IOUtils.toString(
352 classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
353 configData = IOUtils.toString(
354 classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
355 } catch (Exception e1) {
356 logger.error("Exception Occured" + e1);
358 PolicyEntity entity = new PolicyEntity();
359 entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
360 entity.setPolicyData(policyContent);
361 entity.setScope("com");
362 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
363 configurationEntity.setConfigBody(configData);
364 configurationEntity.setConfigType("OTHER");
365 configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
366 configurationEntity.setDescription("test");
367 entity.setConfigurationData(configurationEntity);
368 policyData.add(entity);
369 PolicyManagerServlet servlet = new PolicyManagerServlet();
370 PolicyController controller = mock(PolicyController.class);
371 List<String> list = new ArrayList<>();
373 "{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
374 + " onlyFolders: false}}");
375 for (int i = 0; i < list.size(); i++) {
376 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
378 when(request.getReader()).thenReturn(reader);
379 when(controller.getRoles("Test")).thenReturn(rolesdata);
380 when(controller.getDataByQuery(
381 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
382 .thenReturn(policyData);
383 servlet.setPolicyController(controller);
384 servlet.setTestUserId("Test");
385 servlet.doPost(request, response);
386 } catch (Exception e1) {
387 logger.error("Exception Occured" + e1);
393 @SuppressWarnings("static-access")
395 public void editClosedLoopFaultPolicyTest() {
396 List<Object> policyData = new ArrayList<>();
397 String policyContent = "";
398 String configData = "";
400 ClassLoader classLoader = getClass().getClassLoader();
401 policyContent = IOUtils.toString(
402 classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
403 configData = IOUtils.toString(classLoader
404 .getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
405 } catch (Exception e1) {
406 logger.error("Exception Occured" + e1);
408 PolicyEntity entity = new PolicyEntity();
409 entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
410 entity.setPolicyData(policyContent);
411 entity.setScope("com");
412 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
413 configurationEntity.setConfigBody(configData);
414 configurationEntity.setConfigType("JSON");
415 configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
416 configurationEntity.setDescription("test");
417 entity.setConfigurationData(configurationEntity);
418 policyData.add(entity);
419 PolicyManagerServlet servlet = new PolicyManagerServlet();
420 PolicyController controller = mock(PolicyController.class);
421 List<String> list = new ArrayList<>();
423 "{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
424 + " onlyFolders: false}}");
425 for (int i = 0; i < list.size(); i++) {
426 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
428 when(request.getReader()).thenReturn(reader);
429 when(controller.getRoles("Test")).thenReturn(rolesdata);
430 when(controller.getDataByQuery(
431 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
432 .thenReturn(policyData);
433 servlet.setPolicyController(controller);
434 servlet.setTestUserId("Test");
435 servlet.doPost(request, response);
436 } catch (Exception e1) {
437 logger.error("Exception Occured" + e1);
443 @SuppressWarnings("static-access")
445 public void editClosedLoopPMPolicyTest() {
446 List<Object> policyData = new ArrayList<>();
447 String policyContent = "";
448 String configData = "";
450 ClassLoader classLoader = getClass().getClassLoader();
451 policyContent = IOUtils.toString(
452 classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
453 configData = IOUtils.toString(
454 classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
455 } catch (Exception e1) {
456 logger.error("Exception Occured" + e1);
458 PolicyEntity entity = new PolicyEntity();
459 entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
460 entity.setPolicyData(policyContent);
461 entity.setScope("com");
462 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
463 configurationEntity.setConfigBody(configData);
464 configurationEntity.setConfigType("JSON");
465 configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
466 configurationEntity.setDescription("test");
467 entity.setConfigurationData(configurationEntity);
468 policyData.add(entity);
469 PolicyManagerServlet servlet = new PolicyManagerServlet();
470 PolicyController controller = mock(PolicyController.class);
471 List<String> list = new ArrayList<>();
472 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
473 + " onlyFolders: false}}");
474 for (int i = 0; i < list.size(); i++) {
475 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
477 when(request.getReader()).thenReturn(reader);
478 when(controller.getRoles("Test")).thenReturn(rolesdata);
479 when(controller.getDataByQuery(
480 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
481 .thenReturn(policyData);
482 servlet.setPolicyController(controller);
483 servlet.setTestUserId("Test");
484 servlet.doPost(request, response);
485 } catch (Exception e1) {
486 logger.error("Exception Occured" + e1);
492 @SuppressWarnings("static-access")
494 public void editMicroServicePolicyTest() {
495 GroupPolicyScopeList groupData = new GroupPolicyScopeList();
496 groupData.setGroupName("Test");
497 groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
498 + "closedLoopControlName=SampleClosedLoop");
499 List<Object> groupListData = new ArrayList<>();
500 groupListData.add(groupData);
501 commonClassDao = mock(CommonClassDao.class);
502 CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
503 List<Object> policyData = new ArrayList<>();
504 String policyContent = "";
505 String configData = "";
507 ClassLoader classLoader = getClass().getClassLoader();
509 IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
511 .toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
512 } catch (Exception e1) {
513 logger.error("Exception Occured" + e1);
515 PolicyEntity entity = new PolicyEntity();
516 entity.setPolicyName("Config_MS_vFirewall.1.xml");
517 entity.setPolicyData(policyContent);
518 entity.setScope("com");
519 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
520 configurationEntity.setConfigBody(configData);
521 configurationEntity.setConfigType("JSON");
522 configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
523 configurationEntity.setDescription("test");
524 entity.setConfigurationData(configurationEntity);
525 policyData.add(entity);
526 PolicyManagerServlet servlet = new PolicyManagerServlet();
527 PolicyController controller = mock(PolicyController.class);
528 List<String> list = new ArrayList<>();
530 "{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
531 for (int i = 0; i < list.size(); i++) {
532 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
534 when(request.getReader()).thenReturn(reader);
535 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
536 "resource=SampleResource,service=SampleService,type=SampleType,"
537 + "closedLoopControlName=SampleClosedLoop"))
538 .thenReturn(groupListData);
539 when(controller.getRoles("Test")).thenReturn(rolesdata);
540 when(controller.getDataByQuery(
541 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
542 .thenReturn(policyData);
543 servlet.setPolicyController(controller);
544 servlet.setTestUserId("Test");
545 servlet.doPost(request, response);
546 } catch (Exception e1) {
547 logger.error("Exception Occured" + e1);
553 @SuppressWarnings("static-access")
555 public void editFirewallPolicyTest() {
556 List<Object> policyData = new ArrayList<>();
557 String policyContent = "";
558 String configData = "";
560 ClassLoader classLoader = getClass().getClassLoader();
561 policyContent = IOUtils.toString(
562 classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
563 configData = IOUtils.toString(
564 classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
565 } catch (Exception e1) {
566 logger.error("Exception Occured" + e1);
568 PolicyEntity entity = new PolicyEntity();
569 entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
570 entity.setPolicyData(policyContent);
571 entity.setScope("com");
572 ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
573 configurationEntity.setConfigBody(configData);
574 configurationEntity.setConfigType("JSON");
575 configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
576 configurationEntity.setDescription("test");
577 entity.setConfigurationData(configurationEntity);
578 policyData.add(entity);
579 PolicyManagerServlet servlet = new PolicyManagerServlet();
580 PolicyController controller = mock(PolicyController.class);
581 List<String> list = new ArrayList<>();
582 list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
583 + " onlyFolders: false}}");
584 for (int i = 0; i < list.size(); i++) {
585 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
587 when(request.getReader()).thenReturn(reader);
588 when(controller.getRoles("Test")).thenReturn(rolesdata);
589 when(controller.getDataByQuery(
590 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
591 .thenReturn(policyData);
592 servlet.setPolicyController(controller);
593 servlet.setTestUserId("Test");
594 servlet.doPost(request, response);
595 } catch (Exception e1) {
596 logger.error("Exception Occured" + e1);
602 @SuppressWarnings("static-access")
604 public void editActionPolicyTest() {
605 List<Object> policyData = new ArrayList<>();
606 String policyContent = "";
607 String configData = "";
609 ClassLoader classLoader = getClass().getClassLoader();
610 policyContent = IOUtils
611 .toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
612 configData = IOUtils.toString(
613 classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
614 } catch (Exception e1) {
615 logger.error("Exception Occured" + e1);
617 PolicyEntity entity = new PolicyEntity();
618 entity.setPolicyName("Action_TestActionPolicy.1.xml");
619 entity.setPolicyData(policyContent);
620 entity.setScope("com");
621 ActionBodyEntity configurationEntity = new ActionBodyEntity();
622 configurationEntity.setActionBody(configData);
623 configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
624 entity.setActionBodyEntity(configurationEntity);
625 policyData.add(entity);
626 PolicyManagerServlet servlet = new PolicyManagerServlet();
627 PolicyController controller = mock(PolicyController.class);
628 List<String> list = new ArrayList<>();
629 list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml',"
630 + " onlyFolders: false}}");
631 for (int i = 0; i < list.size(); i++) {
632 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
634 when(request.getReader()).thenReturn(reader);
635 when(controller.getRoles("Test")).thenReturn(rolesdata);
636 when(controller.getDataByQuery(
637 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
638 .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 editDecisionPolicyTest() {
652 List<Object> policyData = new ArrayList<>();
653 String policyContent = "";
655 ClassLoader classLoader = getClass().getClassLoader();
656 policyContent = IOUtils.toString(classLoader
657 .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<>();
670 "{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
671 + " onlyFolders: false}}");
672 for (int i = 0; i < list.size(); i++) {
673 BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
675 when(request.getReader()).thenReturn(reader);
676 when(controller.getRoles("Test")).thenReturn(rolesdata);
677 when(controller.getDataByQuery(
678 "FROM PolicyEntity where policyName = :split_1 and scope = :split_0", null))
679 .thenReturn(policyData);
680 servlet.setPolicyController(controller);
681 servlet.setTestUserId("Test");
682 servlet.doPost(request, response);
683 } catch (Exception e1) {
684 logger.error("Exception Occured" + e1);
691 public void testAddScope() {
692 PolicyManagerServlet servlet = new PolicyManagerServlet();
693 PolicyController controller = mock(PolicyController.class);
694 List<BufferedReader> readers = new ArrayList<>();
695 readers.add(new BufferedReader(
696 new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
697 readers.add(new BufferedReader(
698 new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
699 readers.add(new BufferedReader(new StringReader(
700 "{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
701 for (int i = 0; i < readers.size(); i++) {
703 when(request.getReader()).thenReturn(readers.get(i));
704 PolicyManagerServlet.setPolicyController(controller);
705 servlet.doPost(request, response);
706 assertTrue(response.getContentAsString() != null
707 && response.getContentAsString().contains("success"));
708 } catch (Exception e1) {
709 logger.error("Exception Occured" + e1);
716 public void testClone() {
717 PolicyManagerServlet servlet = new PolicyManagerServlet();
718 PolicyController controller = mock(PolicyController.class);
719 List<BufferedReader> readers = new ArrayList<>();
720 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
721 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
722 when(controller.getDataByQuery(
723 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0",
724 null)).thenReturn(basePolicyData);
725 readers.add(new BufferedReader(
726 new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
727 + " newPath: 'com.Config_testClone.1.xml'}}")));
728 for (int i = 0; i < readers.size(); i++) {
730 when(request.getReader()).thenReturn(readers.get(i));
731 PolicyManagerServlet.setPolicyController(controller);
732 servlet.doPost(request, response);
733 assertTrue(response.getContentAsString() != null
734 && response.getContentAsString().contains("success"));
735 } catch (Exception e1) {
736 logger.error("Exception Occured" + e1);
743 public void testRename() {
744 PolicyManagerServlet servlet = new PolicyManagerServlet();
745 PolicyController controller = mock(PolicyController.class);
746 List<BufferedReader> readers = new ArrayList<>();
747 when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
748 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
749 when(controller.getDataByQuery(
750 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0",
751 null)).thenReturn(basePolicyData);
752 readers.add(new BufferedReader(
753 new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
754 + " newPath: 'com.Config_testClone.1.xml'}}")));
755 for (int i = 0; i < readers.size(); i++) {
757 when(request.getReader()).thenReturn(readers.get(i));
758 PolicyManagerServlet.setPolicyController(controller);
759 servlet.doPost(request, response);
760 assertTrue(response.getContentAsString() != null
761 && response.getContentAsString().contains("success"));
762 } catch (Exception e1) {
763 logger.error("Exception Occured" + e1);
770 public void testRenameScope() {
771 PolicyManagerServlet servlet = new PolicyManagerServlet();
772 PolicyController controller = mock(PolicyController.class);
773 List<BufferedReader> readers = new ArrayList<>();
774 readers.add(new BufferedReader(
775 new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
776 for (int i = 0; i < readers.size(); i++) {
778 when(request.getReader()).thenReturn(readers.get(i));
779 PolicyManagerServlet.setPolicyController(controller);
780 servlet.doPost(request, response);
781 assertTrue(response.getContentAsString() != null
782 && response.getContentAsString().contains("success"));
783 } catch (Exception e1) {
784 logger.error("Exception Occured" + e1);