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