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