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