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-2020 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (C) 2019 Samsung
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  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.assertEquals;
  26 import static org.junit.Assert.assertFalse;
  27 import static org.junit.Assert.assertNotNull;
  28 import static org.junit.Assert.assertTrue;
  29 import static org.junit.Assert.fail;
  30
  31 import java.io.BufferedReader;
  32 import java.io.File;
  33 import java.io.IOException;
  34 import java.io.InputStream;
  35 import java.io.PrintWriter;
  36 import java.io.StringReader;
  37 import java.util.ArrayList;
  38 import java.util.Collections;
  39 import java.util.Date;
  40 import java.util.HashSet;
  41 import java.util.List;
  42 import java.util.Set;
  43 import javax.json.JsonArray;
  44 import javax.script.SimpleBindings;
  45 import javax.servlet.ServletConfig;
  46 import javax.servlet.http.HttpServletRequest;
  47 import javax.servlet.http.HttpServletResponse;
  48 import javax.servlet.http.HttpSession;
  49 import org.apache.commons.fileupload.FileItem;
  50 import org.apache.commons.fileupload.servlet.ServletFileUpload;
  51 import org.apache.commons.io.IOUtils;
  52 import org.json.JSONArray;
  53 import org.json.JSONObject;
  54 import org.junit.Before;
  55 import org.junit.Test;
  56 import org.junit.runner.RunWith;
  57 import org.mockito.Mockito;
  58 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  59 import org.onap.policy.common.logging.flexlogger.Logger;
  60 import org.onap.policy.controller.CreateDcaeMicroServiceController;
  61 import org.onap.policy.controller.PolicyController;
  62 import org.onap.policy.model.Roles;
  63 import org.onap.policy.rest.dao.CommonClassDao;
  64 import org.onap.policy.rest.jpa.ActionBodyEntity;
  65 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
  66 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  67 import org.onap.policy.rest.jpa.PolicyEditorScopes;
  68 import org.onap.policy.rest.jpa.PolicyEntity;
  69 import org.onap.policy.rest.jpa.PolicyVersion;
  70 import org.onap.policy.rest.jpa.UserInfo;
  71 import org.onap.policy.utils.UserUtils.Pair;
  72 import org.onap.portalsdk.core.domain.User;
  73 import org.onap.portalsdk.core.util.SystemProperties;
  74 import org.onap.portalsdk.core.web.support.UserUtils;
  75 import org.powermock.api.mockito.PowerMockito;
  76 import org.powermock.core.classloader.annotations.PrepareForTest;
  77 import org.powermock.modules.junit4.PowerMockRunner;
  78 import org.powermock.reflect.Whitebox;
  79 import org.springframework.mock.web.MockHttpServletResponse;
  80
  81 @RunWith(PowerMockRunner.class)
  82 public class PolicyManagerServletTest extends Mockito {
  83
  84     private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
  85     private List<String> headers = new ArrayList<String>();
  86
  87     private static List<Object> rolesdata;
  88     private static List<Object> basePolicyData;
  89     private static List<Object> policyEditorScopes;
  90     private static List<Object> policyVersion;
  91     private static CommonClassDao commonClassDao;
  92     private ConfigurationDataEntity configurationEntity;
  93     private HttpServletRequest request;
  94     private MockHttpServletResponse response;
  95
  96     /**
  97      * setUp.
  98      *
  99      * @throws Exception should not get one
 100      */
 101     @Before
 102     public void setUp() throws Exception {
 103         logger.info("setUp: Entering");
 104
 105         request = mock(HttpServletRequest.class);
 106         response = new MockHttpServletResponse();
 107
 108         PolicyController.setjUnit(true);
 109         UserInfo userinfo = new UserInfo();
 110         userinfo.setUserLoginId("Test");
 111         userinfo.setUserName("Test");
 112         // Roles Data
 113         rolesdata = new ArrayList<>();
 114         Roles roles = new Roles();
 115         roles.setLoginId("Test");
 116         roles.setRole("super-admin");
 117         Roles roles1 = new Roles();
 118         roles1.setId(1);
 119         roles1.setName("Test");
 120         assertTrue("Test".equals(roles1.getName()));
 121         roles1.setLoginId("Test");
 122         roles1.setRole("admin");
 123         roles1.setScope("['com','Test']");
 124         rolesdata.add(roles);
 125         rolesdata.add(roles1);
 126
 127         // PolicyEntity Data
 128         basePolicyData = new ArrayList<>();
 129         String policyContent = "";
 130         try {
 131             ClassLoader classLoader = getClass().getClassLoader();
 132             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
 133         } catch (Exception e1) {
 134             logger.error("Exception Occured" + e1);
 135         }
 136         PolicyEntity entity = new PolicyEntity();
 137         entity.setPolicyName("Config_SampleTest.1.xml");
 138         entity.setPolicyData(policyContent);
 139         entity.setScope("com");
 140         configurationEntity = new ConfigurationDataEntity();
 141         configurationEntity.setConfigBody("Sample Test");
 142         configurationEntity.setConfigType("OTHER");
 143         configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
 144         configurationEntity.setDescription("test");
 145         entity.setConfigurationData(configurationEntity);
 146         basePolicyData.add(entity);
 147
 148         // PolicyEditorScopes data
 149         policyEditorScopes = new ArrayList<>();
 150         PolicyEditorScopes scopes = new PolicyEditorScopes();
 151         scopes.setScopeName("com");
 152         scopes.setUserCreatedBy(userinfo);
 153         scopes.setUserModifiedBy(userinfo);
 154         PolicyEditorScopes scopes1 = new PolicyEditorScopes();
 155         scopes1.setScopeName("com\\Test");
 156         scopes1.setUserCreatedBy(userinfo);
 157         scopes1.setUserModifiedBy(userinfo);
 158         policyEditorScopes.add(scopes);
 159         policyEditorScopes.add(scopes1);
 160
 161         // PolicyVersion data
 162         policyVersion = new ArrayList<>();
 163         PolicyVersion policy = new PolicyVersion();
 164         policy.setPolicyName("com\\Config_SampleTest1206");
 165         policy.setActiveVersion(1);
 166         policy.setHigherVersion(1);
 167         policy.setCreatedBy("Test");
 168         policy.setModifiedBy("Test");
 169         policyVersion.add(policy);
 170
 171         HttpSession mockSession = mock(HttpSession.class);
 172         User user = new User();
 173         user.setOrgUserId("Test");
 174         Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
 175         Mockito.when(request.getSession(false)).thenReturn(mockSession);
 176         commonClassDao = mock(CommonClassDao.class);
 177
 178     }
 179
 180     @Test
 181     public void testInit() {
 182         PolicyManagerServlet servlet = new PolicyManagerServlet();
 183         ServletConfig servletConfig = mock(ServletConfig.class);
 184         try {
 185             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 186             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 187             System.setProperty("xacml.rest.admin.closedLoopJSON",
 188                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 189                             + "resources" + File.separator + "JSONConfig.json");
 190             servlet.init(servletConfig);
 191
 192             assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
 193             assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
 194
 195         } catch (Exception e1) {
 196             logger.error("Exception Occured" + e1);
 197             fail();
 198         }
 199     }
 200
 201     @Test
 202     public void testBadInitJson() {
 203         PolicyManagerServlet servlet = new PolicyManagerServlet();
 204         ServletConfig servletConfig = mock(ServletConfig.class);
 205         try {
 206             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 207             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 208             System.setProperty("xacml.rest.admin.closedLoopJSON",
 209                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 210                             + "resources" + File.separator + "JSONConfig.foo");
 211             servlet.init(servletConfig);
 212         } catch (Exception e1) {
 213             logger.error("Exception Occured" + e1);
 214             fail();
 215         }
 216     }
 217
 218     @Test
 219     public void testBadInitJsonInvalidFile() {
 220         PolicyManagerServlet servlet = new PolicyManagerServlet();
 221         ServletConfig servletConfig = mock(ServletConfig.class);
 222         try {
 223             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 224             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 225             System.setProperty("xacml.rest.admin.closedLoopJSON",
 226                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 227                             + "resources" + File.separator + "IDonotExist.json");
 228             servlet.init(servletConfig);
 229         } catch (Exception e1) {
 230             logger.error("Exception Occured" + e1);
 231             fail();
 232         }
 233     }
 234
 235     @SuppressWarnings("static-access")
 236     @Test
 237     public void testDescribePolicy() {
 238         PolicyManagerServlet servlet = new PolicyManagerServlet();
 239         PolicyController controller = mock(PolicyController.class);
 240         BufferedReader reader = new BufferedReader(
 241                 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
 242         try {
 243             when(request.getReader()).thenReturn(reader);
 244             String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
 245             when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
 246             servlet.setPolicyController(controller);
 247             servlet.doPost(request, response);
 248         } catch (Exception e1) {
 249             logger.error("Exception Occured" + e1);
 250             fail();
 251         }
 252     }
 253
 254     @SuppressWarnings("static-access")
 255     @Test
 256     public void testPolicyScopeList() {
 257         PolicyManagerServlet servlet = new PolicyManagerServlet();
 258         PolicyController controller = mock(PolicyController.class);
 259         List<String> list = new ArrayList<>();
 260         list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
 261         list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
 262         for (int i = 0; i < list.size(); i++) {
 263             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 264             try {
 265                 when(request.getReader()).thenReturn(reader);
 266                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 267                 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
 268                 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
 269                         .thenReturn(policyEditorScopes);
 270                 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
 271                         .thenReturn(policyVersion);
 272                 servlet.setPolicyController(controller);
 273                 servlet.setTestUserId("Test");
 274                 servlet.doPost(request, response);
 275             } catch (Exception e1) {
 276                 logger.error("Exception Occured" + e1);
 277                 fail();
 278             }
 279         }
 280     }
 281
 282     @SuppressWarnings("static-access")
 283     @Test
 284     public void editBasePolicyTest() {
 285         PolicyManagerServlet servlet = new PolicyManagerServlet();
 286         PolicyController controller = mock(PolicyController.class);
 287         List<String> list = new ArrayList<>();
 288         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
 289         for (int i = 0; i < list.size(); i++) {
 290             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 291             try {
 292                 when(request.getReader()).thenReturn(reader);
 293                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 294                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 295                         null)).thenReturn(basePolicyData);
 296                 servlet.setPolicyController(controller);
 297                 servlet.setTestUserId("Test");
 298                 servlet.doPost(request, response);
 299             } catch (Exception e1) {
 300                 logger.error("Exception Occured" + e1);
 301                 fail();
 302             }
 303         }
 304     }
 305
 306     @SuppressWarnings("static-access")
 307     @Test
 308     public void editBRMSParamPolicyTest() {
 309         List<Object> policyData = new ArrayList<>();
 310         String policyContent = "";
 311         String configData = "";
 312         try {
 313             ClassLoader classLoader = getClass().getClassLoader();
 314             policyContent =
 315                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 316             configData = IOUtils
 317                     .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
 318         } catch (Exception e1) {
 319             logger.error("Exception Occured" + e1);
 320         }
 321         PolicyEntity entity = new PolicyEntity();
 322         entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 323         entity.setPolicyData(policyContent);
 324         entity.setScope("com");
 325         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 326         configurationEntity.setConfigBody(configData);
 327         configurationEntity.setConfigType("OTHER");
 328         configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
 329         configurationEntity.setDescription("test");
 330         entity.setConfigurationData(configurationEntity);
 331         policyData.add(entity);
 332         PolicyManagerServlet servlet = new PolicyManagerServlet();
 333         PolicyController controller = mock(PolicyController.class);
 334         List<String> list = new ArrayList<>();
 335         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
 336                 + " onlyFolders: false}}");
 337         for (int i = 0; i < list.size(); i++) {
 338             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 339             try {
 340                 when(request.getReader()).thenReturn(reader);
 341                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 342                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 343                         null)).thenReturn(policyData);
 344                 servlet.setPolicyController(controller);
 345                 servlet.setTestUserId("Test");
 346                 servlet.doPost(request, response);
 347             } catch (Exception e1) {
 348                 logger.error("Exception Occured" + e1);
 349                 fail();
 350             }
 351         }
 352     }
 353
 354     @SuppressWarnings("static-access")
 355     @Test
 356     public void editBRMSRawPolicyTest() {
 357         List<Object> policyData = new ArrayList<>();
 358         String policyContent = "";
 359         String configData = "";
 360         try {
 361             ClassLoader classLoader = getClass().getClassLoader();
 362             policyContent =
 363                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
 364             configData =
 365                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
 366         } catch (Exception e1) {
 367             logger.error("Exception Occured" + e1);
 368         }
 369         PolicyEntity entity = new PolicyEntity();
 370         entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
 371         entity.setPolicyData(policyContent);
 372         entity.setScope("com");
 373         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 374         configurationEntity.setConfigBody(configData);
 375         configurationEntity.setConfigType("OTHER");
 376         configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
 377         configurationEntity.setDescription("test");
 378         entity.setConfigurationData(configurationEntity);
 379         policyData.add(entity);
 380         PolicyManagerServlet servlet = new PolicyManagerServlet();
 381         PolicyController controller = mock(PolicyController.class);
 382         List<String> list = new ArrayList<>();
 383         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
 384                 + " onlyFolders: false}}");
 385         for (int i = 0; i < list.size(); i++) {
 386             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 387             try {
 388                 when(request.getReader()).thenReturn(reader);
 389                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 390                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 391                         null)).thenReturn(policyData);
 392                 servlet.setPolicyController(controller);
 393                 servlet.setTestUserId("Test");
 394                 servlet.doPost(request, response);
 395             } catch (Exception e1) {
 396                 logger.error("Exception Occured" + e1);
 397                 fail();
 398             }
 399         }
 400     }
 401
 402     @SuppressWarnings("static-access")
 403     @Test
 404     public void editClosedLoopFaultPolicyTest() {
 405         List<Object> policyData = new ArrayList<>();
 406         String policyContent = "";
 407         String configData = "";
 408         try {
 409             ClassLoader classLoader = getClass().getClassLoader();
 410             policyContent =
 411                     IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
 412             configData =
 413                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
 414         } catch (Exception e1) {
 415             logger.error("Exception Occured" + e1);
 416         }
 417         PolicyEntity entity = new PolicyEntity();
 418         entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
 419         entity.setPolicyData(policyContent);
 420         entity.setScope("com");
 421         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 422         configurationEntity.setConfigBody(configData);
 423         configurationEntity.setConfigType("JSON");
 424         configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
 425         configurationEntity.setDescription("test");
 426         entity.setConfigurationData(configurationEntity);
 427         policyData.add(entity);
 428         PolicyManagerServlet servlet = new PolicyManagerServlet();
 429         PolicyController controller = mock(PolicyController.class);
 430         List<String> list = new ArrayList<>();
 431         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
 432                 + " onlyFolders: false}}");
 433         for (int i = 0; i < list.size(); i++) {
 434             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 435             try {
 436                 when(request.getReader()).thenReturn(reader);
 437                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 438                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 439                         null)).thenReturn(policyData);
 440                 servlet.setPolicyController(controller);
 441                 servlet.setTestUserId("Test");
 442                 servlet.doPost(request, response);
 443             } catch (Exception e1) {
 444                 logger.error("Exception Occured" + e1);
 445                 fail();
 446             }
 447         }
 448     }
 449
 450     @SuppressWarnings("static-access")
 451     @Test
 452     public void editClosedLoopPMPolicyTest() {
 453         List<Object> policyData = new ArrayList<>();
 454         String policyContent = "";
 455         String configData = "";
 456         try {
 457             ClassLoader classLoader = getClass().getClassLoader();
 458             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
 459             configData =
 460                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
 461         } catch (Exception e1) {
 462             logger.error("Exception Occured" + e1);
 463         }
 464         PolicyEntity entity = new PolicyEntity();
 465         entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
 466         entity.setPolicyData(policyContent);
 467         entity.setScope("com");
 468         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 469         configurationEntity.setConfigBody(configData);
 470         configurationEntity.setConfigType("JSON");
 471         configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
 472         configurationEntity.setDescription("test");
 473         entity.setConfigurationData(configurationEntity);
 474         policyData.add(entity);
 475         PolicyManagerServlet servlet = new PolicyManagerServlet();
 476         PolicyController controller = mock(PolicyController.class);
 477         List<String> list = new ArrayList<>();
 478         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
 479                 + " onlyFolders: false}}");
 480         for (int i = 0; i < list.size(); i++) {
 481             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 482             try {
 483                 when(request.getReader()).thenReturn(reader);
 484                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 485                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 486                         null)).thenReturn(policyData);
 487                 servlet.setPolicyController(controller);
 488                 servlet.setTestUserId("Test");
 489                 servlet.doPost(request, response);
 490             } catch (Exception e1) {
 491                 logger.error("Exception Occured" + e1);
 492                 fail();
 493             }
 494         }
 495     }
 496
 497     @SuppressWarnings("static-access")
 498     @Test
 499     public void editMicroServicePolicyTest() {
 500         GroupPolicyScopeList groupData = new GroupPolicyScopeList();
 501         groupData.setGroupName("Test");
 502         groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
 503                 + "closedLoopControlName=SampleClosedLoop");
 504         List<Object> groupListData = new ArrayList<>();
 505         groupListData.add(groupData);
 506         commonClassDao = mock(CommonClassDao.class);
 507         CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
 508         List<Object> policyData = new ArrayList<>();
 509         String policyContent = "";
 510         String configData = "";
 511         try {
 512             ClassLoader classLoader = getClass().getClassLoader();
 513             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
 514             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
 515         } catch (Exception e1) {
 516             logger.error("Exception Occured" + e1);
 517         }
 518         PolicyEntity entity = new PolicyEntity();
 519         entity.setPolicyName("Config_MS_vFirewall.1.xml");
 520         entity.setPolicyData(policyContent);
 521         entity.setScope("com");
 522         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 523         configurationEntity.setConfigBody(configData);
 524         configurationEntity.setConfigType("JSON");
 525         configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
 526         configurationEntity.setDescription("test");
 527         entity.setConfigurationData(configurationEntity);
 528         policyData.add(entity);
 529         PolicyManagerServlet servlet = new PolicyManagerServlet();
 530         PolicyController controller = mock(PolicyController.class);
 531         List<String> list = new ArrayList<>();
 532         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
 533         for (int i = 0; i < list.size(); i++) {
 534             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 535             try {
 536                 when(request.getReader()).thenReturn(reader);
 537                 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
 538                         "resource=SampleResource,service=SampleService,type=SampleType,"
 539                                 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
 540                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 541                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 542                         null)).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);
 548                 fail();
 549             }
 550         }
 551     }
 552
 553     @SuppressWarnings("static-access")
 554     @Test
 555     public void editFirewallPolicyTest() {
 556         List<Object> policyData = new ArrayList<>();
 557         String policyContent = "";
 558         String configData = "";
 559         try {
 560             ClassLoader classLoader = getClass().getClassLoader();
 561             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
 562             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
 563         } catch (Exception e1) {
 564             logger.error("Exception Occured" + e1);
 565         }
 566         PolicyEntity entity = new PolicyEntity();
 567         entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
 568         entity.setPolicyData(policyContent);
 569         entity.setScope("com");
 570         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 571         configurationEntity.setConfigBody(configData);
 572         configurationEntity.setConfigType("JSON");
 573         configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
 574         configurationEntity.setDescription("test");
 575         entity.setConfigurationData(configurationEntity);
 576         policyData.add(entity);
 577         PolicyManagerServlet servlet = new PolicyManagerServlet();
 578         PolicyController controller = mock(PolicyController.class);
 579         List<String> list = new ArrayList<>();
 580         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
 581                 + " onlyFolders: false}}");
 582         for (int i = 0; i < list.size(); i++) {
 583             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 584             try {
 585                 when(request.getReader()).thenReturn(reader);
 586                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 587                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 588                         null)).thenReturn(policyData);
 589                 servlet.setPolicyController(controller);
 590                 servlet.setTestUserId("Test");
 591                 servlet.doPost(request, response);
 592             } catch (Exception e1) {
 593                 logger.error("Exception Occured" + e1);
 594                 fail();
 595             }
 596         }
 597     }
 598
 599     @SuppressWarnings("static-access")
 600     @Test
 601     public void editActionPolicyTest() {
 602         List<Object> policyData = new ArrayList<>();
 603         String policyContent = "";
 604         String configData = "";
 605         try {
 606             ClassLoader classLoader = getClass().getClassLoader();
 607             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
 608             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
 609         } catch (Exception e1) {
 610             logger.error("Exception Occured" + e1);
 611         }
 612         PolicyEntity entity = new PolicyEntity();
 613         entity.setPolicyName("Action_TestActionPolicy.1.xml");
 614         entity.setPolicyData(policyContent);
 615         entity.setScope("com");
 616         ActionBodyEntity configurationEntity = new ActionBodyEntity();
 617         configurationEntity.setActionBody(configData);
 618         configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
 619         entity.setActionBodyEntity(configurationEntity);
 620         policyData.add(entity);
 621         PolicyManagerServlet servlet = new PolicyManagerServlet();
 622         PolicyController controller = mock(PolicyController.class);
 623         List<String> list = new ArrayList<>();
 624         list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
 625         for (int i = 0; i < list.size(); i++) {
 626             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 627             try {
 628                 when(request.getReader()).thenReturn(reader);
 629                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 630                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 631                         null)).thenReturn(policyData);
 632                 servlet.setPolicyController(controller);
 633                 servlet.setTestUserId("Test");
 634                 servlet.doPost(request, response);
 635             } catch (Exception e1) {
 636                 logger.error("Exception Occured" + e1);
 637                 fail();
 638             }
 639         }
 640     }
 641
 642     @SuppressWarnings("static-access")
 643     @Test
 644     public void editDecisionPolicyTest() {
 645         List<Object> policyData = new ArrayList<>();
 646         String policyContent = "";
 647         try {
 648             ClassLoader classLoader = getClass().getClassLoader();
 649             policyContent = IOUtils
 650                     .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
 651         } catch (Exception e1) {
 652             logger.error("Exception Occured" + e1);
 653         }
 654         PolicyEntity entity = new PolicyEntity();
 655         entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
 656         entity.setPolicyData(policyContent);
 657         entity.setScope("com");
 658         policyData.add(entity);
 659         PolicyManagerServlet servlet = new PolicyManagerServlet();
 660         PolicyController controller = mock(PolicyController.class);
 661         List<String> list = new ArrayList<>();
 662         list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
 663                 + " onlyFolders: false}}");
 664         for (int i = 0; i < list.size(); i++) {
 665             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 666             try {
 667                 when(request.getReader()).thenReturn(reader);
 668                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 669                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 670                         null)).thenReturn(policyData);
 671                 servlet.setPolicyController(controller);
 672                 servlet.setTestUserId("Test");
 673                 servlet.doPost(request, response);
 674             } catch (Exception e1) {
 675                 logger.error("Exception Occured" + e1);
 676                 fail();
 677             }
 678         }
 679     }
 680
 681     @Test
 682     public void testAddScope() {
 683         PolicyManagerServlet servlet = new PolicyManagerServlet();
 684         PolicyController controller = mock(PolicyController.class);
 685         List<BufferedReader> readers = new ArrayList<>();
 686         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
 687         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
 688         readers.add(new BufferedReader(
 689                 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
 690         for (int i = 0; i < readers.size(); i++) {
 691             try {
 692                 when(request.getReader()).thenReturn(readers.get(i));
 693                 PolicyManagerServlet.setPolicyController(controller);
 694                 servlet.doPost(request, response);
 695                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 696             } catch (Exception e1) {
 697                 logger.error("Exception Occured" + e1);
 698                 fail();
 699             }
 700         }
 701     }
 702
 703     @Test
 704     public void testClone() {
 705         PolicyManagerServlet servlet = new PolicyManagerServlet();
 706         PolicyController controller = mock(PolicyController.class);
 707         List<BufferedReader> readers = new ArrayList<>();
 708         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
 709                 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 710         when(controller.getDataByQuery(
 711                 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
 712                         .thenReturn(basePolicyData);
 713         readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
 714                 + " newPath: 'com.Config_testClone.1.xml'}}")));
 715         for (int i = 0; i < readers.size(); i++) {
 716             try {
 717                 when(request.getReader()).thenReturn(readers.get(i));
 718                 PolicyManagerServlet.setPolicyController(controller);
 719                 servlet.doPost(request, response);
 720                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 721             } catch (Exception e1) {
 722                 logger.error("Exception Occured" + e1);
 723                 fail();
 724             }
 725         }
 726     }
 727
 728     @Test
 729     public void testRename() {
 730         PolicyManagerServlet servlet = new PolicyManagerServlet();
 731         PolicyController controller = mock(PolicyController.class);
 732         List<BufferedReader> readers = new ArrayList<>();
 733         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
 734                 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 735         when(controller.getDataByQuery(
 736                 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
 737                         .thenReturn(basePolicyData);
 738         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
 739                 + " newPath: 'com.Config_testClone.1.xml'}}")));
 740         for (int i = 0; i < readers.size(); i++) {
 741             try {
 742                 when(request.getReader()).thenReturn(readers.get(i));
 743                 PolicyManagerServlet.setPolicyController(controller);
 744                 servlet.doPost(request, response);
 745                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 746             } catch (Exception e1) {
 747                 logger.error("Exception Occured" + e1);
 748                 fail();
 749             }
 750         }
 751     }
 752
 753     @Test
 754     public void testRenameScope() throws Exception {
 755         PolicyManagerServlet servlet = new PolicyManagerServlet();
 756         PolicyController controller = mock(PolicyController.class);
 757         List<BufferedReader> readers = new ArrayList<>();
 758         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
 759         for (int i = 0; i < readers.size(); i++) {
 760             try {
 761                 when(request.getReader()).thenReturn(readers.get(i));
 762                 PolicyManagerServlet.setPolicyController(controller);
 763                 servlet.doPost(request, response);
 764                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 765             } catch (Exception e1) {
 766                 logger.error("Exception Occured" + e1);
 767                 fail();
 768             }
 769         }
 770
 771         String inScopeName = "\\\\\\\\inScopeName";
 772         String newScopeName = "\\\\\\\\newScopeName";
 773         List<Object> scopesList = new ArrayList<Object>();
 774         PolicyEditorScopes mockPolicyEditorScope = Mockito.mock(PolicyEditorScopes.class);
 775         scopesList.add(mockPolicyEditorScope);
 776         when(mockPolicyEditorScope.getScopeName()).thenReturn("inScopeName");
 777         Whitebox.invokeMethod(servlet, "renameScope", scopesList, inScopeName, newScopeName, controller);
 778         verify(mockPolicyEditorScope, atLeast(1)).getScopeName();
 779     }
 780
 781     @Test
 782     public void testSetPolicyNames() {
 783         JsonArray mockJsonArray = Mockito.mock(JsonArray.class);
 784         PolicyManagerServlet.setPolicyNames(mockJsonArray);
 785         assertEquals(mockJsonArray, PolicyManagerServlet.getPolicyNames());
 786     }
 787
 788     @Test
 789     public void testDoPostSetErrorException() throws IOException {
 790         PolicyManagerServlet servlet = new PolicyManagerServlet();
 791         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 792         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 793         doThrow(IOException.class).when(mockRequest).getReader();
 794         doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
 795         servlet.doPost(mockRequest, mockResponse);
 796         verify(mockRequest).getReader();
 797     }
 798
 799     @Test
 800     public void testDoPostException() throws IOException {
 801         PolicyManagerServlet servlet = new PolicyManagerServlet();
 802         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 803         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 804
 805         doThrow(IOException.class).when(mockRequest).getReader();
 806         doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
 807         doThrow(IOException.class).when(mockResponse).getWriter();
 808
 809         servlet.doPost(mockRequest, mockResponse);
 810         verify(mockRequest).getReader();
 811         verify(mockResponse).getWriter();
 812     }
 813
 814     @Test
 815     public void testDoPostSuccess() throws IOException {
 816         PolicyManagerServlet servlet = new PolicyManagerServlet();
 817         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 818         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 819         PrintWriter mockPrintWriter = Mockito.mock(PrintWriter.class);
 820
 821         doThrow(IOException.class).when(mockRequest).getReader();
 822         when(mockResponse.getWriter()).thenReturn(mockPrintWriter);
 823
 824         servlet.doPost(null, mockResponse);
 825         verify(mockResponse).getWriter();
 826     }
 827
 828     @PrepareForTest(ServletFileUpload.class)
 829     @Test
 830     public void testDoPostUploadFileException() {
 831         PolicyManagerServlet servlet = new PolicyManagerServlet();
 832         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 833         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 834         PowerMockito.mockStatic(ServletFileUpload.class);
 835         when(ServletFileUpload.isMultipartContent(mockRequest)).thenReturn(true);
 836         servlet.doPost(mockRequest, mockResponse);
 837         PowerMockito.verifyStatic(ServletFileUpload.class, Mockito.times(1));
 838     }
 839
 840     @SuppressWarnings("unchecked")
 841     @PrepareForTest({PolicyController.class, IOUtils.class})
 842     @Test
 843     public void testProcessFormFile() throws Exception {
 844         PolicyManagerServlet servlet = new PolicyManagerServlet();
 845         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 846         FileItem mockFileItem = Mockito.mock(FileItem.class);
 847         PowerMockito.mockStatic(PolicyController.class);
 848         PowerMockito.mockStatic(IOUtils.class);
 849         InputStream mockInputStream = Mockito.mock(InputStream.class);
 850
 851         long fileSizeLimit = 10;
 852         when(PolicyController.getFileSizeLimit()).thenReturn(fileSizeLimit);
 853         when(mockFileItem.getName()).thenReturn("testFileName.xls");
 854         when(mockFileItem.getInputStream()).thenReturn(mockInputStream);
 855         when(mockFileItem.getSize()).thenReturn(fileSizeLimit + 1);
 856
 857         Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem);
 858         verify(mockFileItem, atLeast(1)).getName();
 859         verify(mockFileItem, atLeast(1)).getSize();
 860
 861         when(mockFileItem.getName()).thenReturn("testFileName.txt");
 862         Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem);
 863         verify(mockFileItem, atLeast(1)).getName();
 864
 865         when(mockFileItem.getSize()).thenReturn(fileSizeLimit);
 866         when(mockFileItem.getName()).thenReturn("testFileName.xls");
 867         when(mockFileItem.getInputStream()).thenThrow(IOException.class);
 868         Whitebox.invokeMethod(servlet, "processFormFile", mockRequest, mockFileItem);
 869         verify(mockFileItem, atLeast(1)).getName();
 870         verify(mockFileItem, atLeast(1)).getInputStream();
 871         verify(mockFileItem, atLeast(1)).getSize();
 872     }
 873
 874     @Test
 875     public void testSearchPolicyList() throws Exception {
 876         PolicyManagerServlet servlet = new PolicyManagerServlet();
 877         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 878         JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
 879
 880         mockJSONObject.append("policyList", "sampleValue");
 881
 882         Object res = Whitebox.invokeMethod(servlet, "searchPolicyList", mockJSONObject, mockRequest);
 883         assert (res instanceof JSONObject);
 884         assertNotNull(((JSONObject) res).get("result"));
 885     }
 886
 887     @PrepareForTest({UserUtils.class, org.onap.policy.utils.UserUtils.class})
 888     @Test
 889     public void testLookupPolicyData() throws Exception {
 890         PowerMockito.mockStatic(UserUtils.class);
 891         PowerMockito.mockStatic(org.onap.policy.utils.UserUtils.class);
 892         PolicyManagerServlet servlet = new PolicyManagerServlet();
 893         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 894         User mockUser = Mockito.mock(User.class);
 895         UserInfo mockUserInfo = Mockito.mock(UserInfo.class);
 896         PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
 897         List<JSONObject> resultList = new ArrayList<>();
 898         JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
 899         resultList.add(mockJSONObject);
 900
 901         Date mockDate = Mockito.mock(Date.class);
 902         List<Object> policyDataList = new ArrayList<>();
 903         PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
 904         policyDataList.add(mockPolicyVersion);
 905         JSONArray mockJSONArray = Mockito.mock(JSONArray.class);
 906
 907         List<Object> rolesList = new ArrayList<>();
 908         Roles adminRole = Mockito.mock(Roles.class);
 909         Roles editorRole = Mockito.mock(Roles.class);
 910         Roles guestRole = Mockito.mock(Roles.class);
 911         adminRole.setRole("admin");
 912         editorRole.setRole("editor");
 913         guestRole.setRole("guest");
 914
 915         List<Object> filterDataList = new ArrayList<>();
 916         PolicyVersion mockPolicyVersionFilter = Mockito.mock(PolicyVersion.class);
 917         filterDataList.add(mockPolicyVersionFilter);
 918         List<String> listOfRoles = new ArrayList<String>();
 919         Set<String> setOfScopes = new HashSet<String>();
 920         Pair<Set<String>, List<String>> pairList = new Pair<Set<String>, List<String>>(setOfScopes, listOfRoles);
 921
 922         PolicyManagerServlet.setPolicyController(mockPolicyController);
 923         PowerMockito.when(UserUtils.getUserSession(mockRequest)).thenReturn(mockUser);
 924         when(mockPolicyController.getRoles(any(String.class))).thenReturn(rolesList);
 925         PowerMockito.when(org.onap.policy.utils.UserUtils.checkRoleAndScope(rolesList)).thenReturn(pairList);
 926         when(mockPolicyController.getData(any(Class.class))).thenReturn(filterDataList);
 927         when(mockPolicyVersion.getPolicyName()).thenReturn("sampleName");
 928         when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
 929         when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
 930         when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
 931         when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
 932         when(mockPolicyController.getEntityItem(UserInfo.class, "userLoginId", "sampleUserName"))
 933                 .thenReturn(mockUserInfo);
 934         when(mockUserInfo.getUserName()).thenReturn("testUserName");
 935
 936         Whitebox.invokeMethod(servlet, "getPolicyControllerInstance");
 937
 938         boolean result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
 939                 mockPolicyController, resultList);
 940
 941         assertTrue(result);
 942         verify(mockPolicyController, atLeast(1)).getRoles(any(String.class));
 943         verify(mockPolicyController, atLeast(1)).getRoles(any(String.class));
 944         verify(mockPolicyController, atLeast(1)).getData(any(Class.class));
 945         verify(mockPolicyController, atLeast(1)).getEntityItem(UserInfo.class, "userLoginId", "sampleUserName");
 946         verify(mockPolicyVersion, atLeast(1)).getPolicyName();
 947         verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
 948         verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
 949         verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
 950         verify(mockPolicyVersion, atLeast(1)).getModifiedBy();
 951         verify(mockUserInfo, atLeast(1)).getUserName();
 952
 953         when(mockPolicyVersionFilter.getPolicyName()).thenReturn("testAdminScope" + File.separator);
 954         result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
 955                 mockPolicyController, resultList);
 956         assertTrue(result);
 957         verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
 958
 959         setOfScopes.add("testAdminScope");
 960         result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
 961                 mockPolicyController, resultList);
 962         assertTrue(result);
 963         verify(mockPolicyVersionFilter, atLeast(1)).getPolicyName();
 964
 965         listOfRoles.add("super-admin");
 966         listOfRoles.add("super-editor");
 967         listOfRoles.add("super-guest");
 968         filterDataList.clear();
 969
 970         result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
 971                 mockPolicyController, resultList);
 972         assertTrue(result);
 973         verify(mockPolicyController, atLeast(1)).getData(any(Class.class));
 974
 975         listOfRoles.clear();
 976         listOfRoles.add("admin");
 977         listOfRoles.add("editor");
 978         listOfRoles.add("guest");
 979         setOfScopes.clear();
 980         result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, null,
 981                 mockPolicyController, resultList);
 982         assertFalse(result);
 983
 984         setOfScopes.add("testScope");
 985         result = Whitebox.invokeMethod(servlet, "lookupPolicyData", mockRequest, policyDataList, mockJSONArray,
 986                 mockPolicyController, resultList);
 987         assertTrue(result);
 988     }
 989
 990     @Test
 991     public void testDeleteEntityFromEsAndPolicyEntityTable() throws Exception {
 992         PolicyManagerServlet servlet = new PolicyManagerServlet();
 993         PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
 994         PolicyRestController mockPolicyRestController = Mockito.mock(PolicyRestController.class);
 995         PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
 996         ConfigurationDataEntity mockConfigDataEntity = Mockito.mock(ConfigurationDataEntity.class);
 997         ActionBodyEntity mockActionBodyEntity = Mockito.mock(ActionBodyEntity.class);
 998
 999         String policyNamewithoutExtension = "Config_";
1000         String configName = "";
1001         String actionBodyName = "";
1002
1003         when(mockPolicyEntity.getScope()).thenReturn("");
1004         when(mockPolicyEntity.getPolicyName()).thenReturn("");
1005         Mockito.doNothing().when(mockPolicyRestController).deleteElasticData(any(String.class));
1006         Mockito.doNothing().when(mockPolicyController).deleteData(mockPolicyEntity);
1007         when(mockPolicyEntity.getConfigurationData()).thenReturn(mockConfigDataEntity);
1008         when(mockPolicyEntity.getActionBodyEntity()).thenReturn(mockActionBodyEntity);
1009         when(mockConfigDataEntity.getConfigurationName()).thenReturn(configName);
1010         when(mockActionBodyEntity.getActionBodyName()).thenReturn(actionBodyName);
1011         when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, configName)).thenReturn("");
1012
1013         Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1014                 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1015
1016         verify(mockPolicyEntity, atLeast(1)).getScope();
1017         verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1018         verify(mockPolicyEntity, atLeast(1)).getConfigurationData();
1019         verify(mockConfigDataEntity, atLeast(1)).getConfigurationName();
1020
1021         policyNamewithoutExtension = "Action_";
1022         when(mockPolicyRestController.notifyOtherPapsToUpdateConfigurations("delete", null, actionBodyName))
1023                 .thenReturn("");
1024
1025         Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1026                 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1027
1028         verify(mockPolicyEntity, atLeast(1)).getScope();
1029         verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1030         verify(mockPolicyEntity, atLeast(1)).getActionBodyEntity();
1031         verify(mockActionBodyEntity, atLeast(1)).getActionBodyName();
1032
1033         policyNamewithoutExtension = "Other_";
1034         Whitebox.invokeMethod(servlet, "deleteEntityFromEsAndPolicyEntityTable", mockPolicyController,
1035                 mockPolicyRestController, mockPolicyEntity, policyNamewithoutExtension);
1036
1037         verify(mockPolicyEntity, atLeast(1)).getScope();
1038         verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1039         verify(mockPolicyRestController, atLeast(1)).deleteElasticData(any(String.class));
1040         verify(mockPolicyController, atLeast(1)).deleteData(mockPolicyEntity);
1041     }
1042
1043     @PrepareForTest(UserUtils.class)
1044     @Test
1045     public void testDelete() throws Exception {
1046         PolicyManagerServlet servlet = new PolicyManagerServlet();
1047         JSONObject mockJSONObject = Mockito.mock(JSONObject.class);
1048         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
1049         User mockUser = Mockito.mock(User.class);
1050         PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1051         PowerMockito.mockStatic(UserUtils.class);
1052         List<Object> policyEntityList = new ArrayList<Object>();
1053         PolicyEntity mockPolicyEntity = Mockito.mock(PolicyEntity.class);
1054         policyEntityList.add(mockPolicyEntity);
1055         long policyId = 1;
1056
1057         PowerMockito.when(UserUtils.getUserSession(mockRequest)).thenReturn(mockUser);
1058         PolicyManagerServlet.setPolicyController(mockPolicyController);
1059         when(mockUser.getOrgUserId()).thenReturn("sampleUserId");
1060         when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.1.xml");
1061         when(mockJSONObject.has("deleteVersion")).thenReturn(true);
1062         when(mockJSONObject.getString("deleteVersion")).thenReturn("ALL");
1063         when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1064                 .thenReturn(policyEntityList);
1065         when(mockPolicyEntity.getPolicyId()).thenReturn(policyId);
1066         when(mockPolicyEntity.getScope()).thenReturn("sampleScope");
1067         when(mockPolicyEntity.getPolicyName()).thenReturn("samplePolicyName");
1068
1069         JSONObject returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1070         assertTrue(returnObj.has("result"));
1071         verify(mockUser, atLeast(1)).getOrgUserId();
1072         verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1073         verify(mockJSONObject, atLeast(1)).has(any(String.class));
1074         verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1075         verify(mockPolicyEntity, atLeast(1)).getPolicyId();
1076         verify(mockPolicyEntity, atLeast(1)).getScope();
1077         verify(mockPolicyEntity, atLeast(1)).getPolicyName();
1078
1079         when(mockJSONObject.getString("path")).thenReturn("/sampleScope\\:samplePolicyName.1.xml");
1080         when(mockJSONObject.getString("deleteVersion")).thenReturn("CURRENT");
1081         returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1082         assertTrue(returnObj.has("result"));
1083         verify(mockJSONObject, atLeast(1)).getString(any(String.class));
1084
1085         when(mockJSONObject.getString("path")).thenReturn("/sampleScope:samplePolicyName.2.txt");
1086         when(mockJSONObject.has("deleteVersion")).thenReturn(false);
1087         returnObj = Whitebox.invokeMethod(servlet, "delete", mockJSONObject, mockRequest);
1088         assertTrue(returnObj.has("result"));
1089         verify(mockJSONObject, atLeast(1)).getString("path");
1090         verify(mockJSONObject, atLeast(1)).has("deleteVersion");
1091     }
1092
1093     @Test
1094     public void testParsePolicyList() throws Exception {
1095         PolicyManagerServlet servlet = new PolicyManagerServlet();
1096         List<JSONObject> resultList = new ArrayList<JSONObject>();
1097         PolicyController mockPolicyController = Mockito.mock(PolicyController.class);
1098         String policyName = "sampleName\\";
1099         String policyVersion = "sampleVersion";
1100         List<Object> activeDataList = new ArrayList<Object>();
1101         PolicyVersion mockPolicyVersion = Mockito.mock(PolicyVersion.class);
1102         activeDataList.add(mockPolicyVersion);
1103         Date mockDate = Mockito.mock(Date.class);
1104
1105         when(mockPolicyController.getDataByQuery(any(String.class), any(SimpleBindings.class)))
1106                 .thenReturn(activeDataList);
1107         when(mockPolicyVersion.getPolicyName()).thenReturn("testPolicyName");
1108         when(mockPolicyVersion.getModifiedDate()).thenReturn(mockDate);
1109         when(mockPolicyVersion.getActiveVersion()).thenReturn(1);
1110         when(mockPolicyVersion.getCreatedBy()).thenReturn("sampleUserName");
1111         when(mockPolicyVersion.getModifiedBy()).thenReturn("sampleUserName");
1112         Whitebox.invokeMethod(servlet, "parsePolicyList", resultList, mockPolicyController, policyName, policyVersion);
1113         verify(mockPolicyController, atLeast(1)).getDataByQuery(any(String.class), any(SimpleBindings.class));
1114         verify(mockPolicyVersion, atLeast(1)).getPolicyName();
1115         verify(mockPolicyVersion, atLeast(1)).getModifiedDate();
1116         verify(mockPolicyVersion, atLeast(1)).getActiveVersion();
1117         verify(mockPolicyVersion, atLeast(1)).getCreatedBy();
1118         verify(mockPolicyVersion, atLeast(1)).getModifiedBy();
1119     }
1120 }