POLICY-SDK-APP/src/test/java/org/onap/policy/admin/PolicyManagerServletTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Engine
   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
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  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=========================================================
  21  */
  22
  23 package org.onap.policy.admin;
  24
  25 import static org.junit.Assert.assertTrue;
  26 import static org.junit.Assert.fail;
  27
  28 import java.io.BufferedReader;
  29 import java.io.File;
  30 import java.io.StringReader;
  31 import java.util.ArrayList;
  32 import java.util.Collections;
  33 import java.util.List;
  34
  35 import javax.servlet.ServletConfig;
  36 import javax.servlet.http.HttpServletRequest;
  37 import javax.servlet.http.HttpSession;
  38
  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;
  59
  60 public class PolicyManagerServletTest extends Mockito {
  61
  62     private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
  63     private List<String> headers = new ArrayList<String>();
  64
  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;
  73
  74     /**
  75      * setUp.
  76      *
  77      * @throws Exception should not get one
  78      */
  79     @Before
  80     public void setUp() throws Exception {
  81         logger.info("setUp: Entering");
  82
  83         request = mock(HttpServletRequest.class);
  84         response = new MockHttpServletResponse();
  85
  86         PolicyController.setjUnit(true);
  87         UserInfo userinfo = new UserInfo();
  88         userinfo.setUserLoginId("Test");
  89         userinfo.setUserName("Test");
  90         // Roles Data
  91         rolesdata = new ArrayList<>();
  92         Roles roles = new Roles();
  93         roles.setLoginId("Test");
  94         roles.setRole("super-admin");
  95         Roles roles1 = new Roles();
  96         roles1.setId(1);
  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);
 104
 105         // PolicyEntity Data
 106         basePolicyData = new ArrayList<>();
 107         String policyContent = "";
 108         try {
 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);
 113         }
 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);
 125
 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);
 138
 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);
 148
 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);
 155
 156     }
 157
 158     @Test
 159     public void testInit() {
 160         PolicyManagerServlet servlet = new PolicyManagerServlet();
 161         ServletConfig servletConfig = mock(ServletConfig.class);
 162         try {
 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);
 169
 170             assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
 171             assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
 172
 173         } catch (Exception e1) {
 174             logger.error("Exception Occured" + e1);
 175             fail();
 176         }
 177     }
 178
 179     @Test
 180     public void testBadInitJson() {
 181         PolicyManagerServlet servlet = new PolicyManagerServlet();
 182         ServletConfig servletConfig = mock(ServletConfig.class);
 183         try {
 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);
 192             fail();
 193         }
 194     }
 195
 196     @Test
 197     public void testBadInitJsonInvalidFile() {
 198         PolicyManagerServlet servlet = new PolicyManagerServlet();
 199         ServletConfig servletConfig = mock(ServletConfig.class);
 200         try {
 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);
 209             fail();
 210         }
 211     }
 212
 213     @SuppressWarnings("static-access")
 214     @Test
 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'}}"));
 220         try {
 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);
 228             fail();
 229         }
 230     }
 231
 232     @SuppressWarnings("static-access")
 233     @Test
 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)));
 242             try {
 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);
 255                 fail();
 256             }
 257         }
 258     }
 259
 260     @SuppressWarnings("static-access")
 261     @Test
 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)));
 269             try {
 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);
 279                 fail();
 280             }
 281         }
 282     }
 283
 284     @SuppressWarnings("static-access")
 285     @Test
 286     public void editBRMSParamPolicyTest() {
 287         List<Object> policyData = new ArrayList<>();
 288         String policyContent = "";
 289         String configData = "";
 290         try {
 291             ClassLoader classLoader = getClass().getClassLoader();
 292             policyContent =
 293                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 294             configData = IOUtils
 295                     .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
 296         } catch (Exception e1) {
 297             logger.error("Exception Occured" + e1);
 298         }
 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)));
 317             try {
 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);
 327                 fail();
 328             }
 329         }
 330     }
 331
 332     @SuppressWarnings("static-access")
 333     @Test
 334     public void editBRMSRawPolicyTest() {
 335         List<Object> policyData = new ArrayList<>();
 336         String policyContent = "";
 337         String configData = "";
 338         try {
 339             ClassLoader classLoader = getClass().getClassLoader();
 340             policyContent =
 341                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
 342             configData =
 343                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
 344         } catch (Exception e1) {
 345             logger.error("Exception Occured" + e1);
 346         }
 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)));
 365             try {
 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);
 375                 fail();
 376             }
 377         }
 378     }
 379
 380     @SuppressWarnings("static-access")
 381     @Test
 382     public void editClosedLoopFaultPolicyTest() {
 383         List<Object> policyData = new ArrayList<>();
 384         String policyContent = "";
 385         String configData = "";
 386         try {
 387             ClassLoader classLoader = getClass().getClassLoader();
 388             policyContent =
 389                     IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
 390             configData =
 391                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
 392         } catch (Exception e1) {
 393             logger.error("Exception Occured" + e1);
 394         }
 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)));
 413             try {
 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);
 423                 fail();
 424             }
 425         }
 426     }
 427
 428     @SuppressWarnings("static-access")
 429     @Test
 430     public void editClosedLoopPMPolicyTest() {
 431         List<Object> policyData = new ArrayList<>();
 432         String policyContent = "";
 433         String configData = "";
 434         try {
 435             ClassLoader classLoader = getClass().getClassLoader();
 436             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
 437             configData =
 438                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
 439         } catch (Exception e1) {
 440             logger.error("Exception Occured" + e1);
 441         }
 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)));
 460             try {
 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);
 470                 fail();
 471             }
 472         }
 473     }
 474
 475     @SuppressWarnings("static-access")
 476     @Test
 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 = "";
 489         try {
 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);
 495         }
 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)));
 513             try {
 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);
 526                 fail();
 527             }
 528         }
 529     }
 530
 531     @SuppressWarnings("static-access")
 532     @Test
 533     public void editFirewallPolicyTest() {
 534         List<Object> policyData = new ArrayList<>();
 535         String policyContent = "";
 536         String configData = "";
 537         try {
 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);
 543         }
 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)));
 562             try {
 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);
 572                 fail();
 573             }
 574         }
 575     }
 576
 577     @SuppressWarnings("static-access")
 578     @Test
 579     public void editActionPolicyTest() {
 580         List<Object> policyData = new ArrayList<>();
 581         String policyContent = "";
 582         String configData = "";
 583         try {
 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);
 589         }
 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)));
 605             try {
 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);
 615                 fail();
 616             }
 617         }
 618     }
 619
 620     @SuppressWarnings("static-access")
 621     @Test
 622     public void editDecisionPolicyTest() {
 623         List<Object> policyData = new ArrayList<>();
 624         String policyContent = "";
 625         try {
 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);
 631         }
 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)));
 644             try {
 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);
 654                 fail();
 655             }
 656         }
 657     }
 658
 659     @Test
 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++) {
 669             try {
 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);
 676                 fail();
 677             }
 678         }
 679     }
 680
 681     @Test
 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++) {
 694             try {
 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);
 701                 fail();
 702             }
 703         }
 704     }
 705
 706     @Test
 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++) {
 719             try {
 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);
 726                 fail();
 727             }
 728         }
 729     }
 730
 731     @Test
 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++) {
 738             try {
 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);
 745                 fail();
 746             }
 747         }
 748     }
 749 }