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