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.Before;
  54 import org.junit.FixMethodOrder;
  55 import org.junit.Test;
  56 import org.junit.runners.MethodSorters;
  57 import org.mockito.Mockito;
  58 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  59 import org.onap.policy.common.logging.flexlogger.Logger;
  60 import org.onap.policy.controller.CreateDcaeMicroServiceController;
  61 import org.onap.policy.controller.PolicyController;
  62 import org.onap.policy.model.Roles;
  63 import org.onap.policy.rest.dao.CommonClassDao;
  64 import org.onap.policy.rest.jpa.ActionBodyEntity;
  65 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
  66 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  67 import org.onap.policy.rest.jpa.PolicyEditorScopes;
  68 import org.onap.policy.rest.jpa.PolicyEntity;
  69 import org.onap.policy.rest.jpa.PolicyVersion;
  70 import org.onap.policy.rest.jpa.UserInfo;
  71 import org.onap.policy.utils.UserUtils.Pair;
  72 import org.onap.portalsdk.core.domain.User;
  73 import org.onap.portalsdk.core.util.SystemProperties;
  74 import org.powermock.reflect.Whitebox;
  75 import org.springframework.mock.web.MockHttpServletResponse;
  76
  77 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  78 public class PolicyManagerServletTest extends Mockito {
  79
  80     private static Logger logger = FlexLogger.getLogger(PolicyManagerServletTest.class);
  81     private List<String> headers = new ArrayList<String>();
  82
  83     private static List<Object> rolesdata;
  84     private static List<Object> basePolicyData;
  85     private static List<Object> policyEditorScopes;
  86     private static List<Object> policyVersion;
  87     private static CommonClassDao commonClassDao;
  88     private ConfigurationDataEntity configurationEntity;
  89     private HttpServletRequest request;
  90     private MockHttpServletResponse response;
  91
  92     /**
  93      * setUp.
  94      *
  95      * @throws Exception should not get one
  96      */
  97     @Before
  98     public void setUp() throws Exception {
  99         logger.info("setUp: Entering");
 100
 101         request = mock(HttpServletRequest.class);
 102         response = new MockHttpServletResponse();
 103
 104         PolicyController.setjUnit(true);
 105         UserInfo userinfo = new UserInfo();
 106         userinfo.setUserLoginId("Test");
 107         userinfo.setUserName("Test");
 108         // Roles Data
 109         rolesdata = new ArrayList<>();
 110         Roles roles = new Roles();
 111         roles.setLoginId("Test");
 112         roles.setRole("super-admin");
 113         Roles roles1 = new Roles();
 114         roles1.setId(1);
 115         roles1.setName("Test");
 116         assertTrue("Test".equals(roles1.getName()));
 117         roles1.setLoginId("Test");
 118         roles1.setRole("admin");
 119         roles1.setScope("['com','Test']");
 120         rolesdata.add(roles);
 121         rolesdata.add(roles1);
 122
 123         // PolicyEntity Data
 124         basePolicyData = new ArrayList<>();
 125         String policyContent = "";
 126         try {
 127             ClassLoader classLoader = getClass().getClassLoader();
 128             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
 129         } catch (Exception e1) {
 130             logger.error("Exception Occured" + e1);
 131         }
 132         PolicyEntity entity = new PolicyEntity();
 133         entity.setPolicyName("Config_SampleTest.1.xml");
 134         entity.setPolicyData(policyContent);
 135         entity.setScope("com");
 136         configurationEntity = new ConfigurationDataEntity();
 137         configurationEntity.setConfigBody("Sample Test");
 138         configurationEntity.setConfigType("OTHER");
 139         configurationEntity.setConfigurationName("com.Config_SampleTest1206.1.txt");
 140         configurationEntity.setDescription("test");
 141         entity.setConfigurationData(configurationEntity);
 142         basePolicyData.add(entity);
 143
 144         // PolicyEditorScopes data
 145         policyEditorScopes = new ArrayList<>();
 146         PolicyEditorScopes scopes = new PolicyEditorScopes();
 147         scopes.setScopeName("com");
 148         scopes.setUserCreatedBy(userinfo);
 149         scopes.setUserModifiedBy(userinfo);
 150         PolicyEditorScopes scopes1 = new PolicyEditorScopes();
 151         scopes1.setScopeName("com\\Test");
 152         scopes1.setUserCreatedBy(userinfo);
 153         scopes1.setUserModifiedBy(userinfo);
 154         policyEditorScopes.add(scopes);
 155         policyEditorScopes.add(scopes1);
 156
 157         // PolicyVersion data
 158         policyVersion = new ArrayList<>();
 159         PolicyVersion policy = new PolicyVersion();
 160         policy.setPolicyName("com\\Config_SampleTest1206");
 161         policy.setActiveVersion(1);
 162         policy.setHigherVersion(1);
 163         policy.setCreatedBy("Test");
 164         policy.setModifiedBy("Test");
 165         policyVersion.add(policy);
 166
 167         HttpSession mockSession = mock(HttpSession.class);
 168         User user = new User();
 169         user.setOrgUserId("Test");
 170         Mockito.when(mockSession.getAttribute(SystemProperties.getProperty("user_attribute_name"))).thenReturn(user);
 171         Mockito.when(request.getSession(false)).thenReturn(mockSession);
 172         commonClassDao = mock(CommonClassDao.class);
 173
 174     }
 175
 176     @Test
 177     public void test01Init() {
 178         PolicyManagerServlet servlet = new PolicyManagerServlet();
 179         ServletConfig servletConfig = mock(ServletConfig.class);
 180         try {
 181             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 182             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 183             System.setProperty("xacml.rest.admin.closedLoopJSON",
 184                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 185                             + "resources" + File.separator + "JSONConfig.json");
 186             servlet.init(servletConfig);
 187
 188             assertTrue(PolicyManagerServlet.getServiceTypeNamesList().size() > 0);
 189             assertTrue(PolicyManagerServlet.getPolicyNames().size() > 0);
 190
 191         } catch (Exception e1) {
 192             logger.error("Exception Occured" + e1);
 193             fail();
 194         }
 195     }
 196
 197     @Test
 198     public void test02BadInitJson() {
 199         PolicyManagerServlet servlet = new PolicyManagerServlet();
 200         ServletConfig servletConfig = mock(ServletConfig.class);
 201         try {
 202             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 203             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 204             System.setProperty("xacml.rest.admin.closedLoopJSON",
 205                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 206                             + "resources" + File.separator + "JSONConfig.foo");
 207             servlet.init(servletConfig);
 208         } catch (Exception e1) {
 209             logger.error("Exception Occured" + e1);
 210             fail();
 211         }
 212     }
 213
 214     @Test
 215     public void test03BadInitJsonInvalidFile() {
 216         PolicyManagerServlet servlet = new PolicyManagerServlet();
 217         ServletConfig servletConfig = mock(ServletConfig.class);
 218         try {
 219             when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 220             when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("xacml.admin.properties");
 221             System.setProperty("xacml.rest.admin.closedLoopJSON",
 222                     new File(".").getCanonicalPath() + File.separator + "src" + File.separator + "test" + File.separator
 223                             + "resources" + File.separator + "IDonotExist.json");
 224             servlet.init(servletConfig);
 225         } catch (Exception e1) {
 226             logger.error("Exception Occured" + e1);
 227             fail();
 228         }
 229     }
 230
 231     @SuppressWarnings("static-access")
 232     @Test
 233     public void test04DescribePolicy() {
 234         PolicyManagerServlet servlet = new PolicyManagerServlet();
 235         PolicyController controller = mock(PolicyController.class);
 236         BufferedReader reader = new BufferedReader(
 237                 new StringReader("{params: { mode: 'DESCRIBEPOLICYFILE', path: 'com.Config_SampleTest1206.1.xml'}}"));
 238         try {
 239             when(request.getReader()).thenReturn(reader);
 240             String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
 241             when(controller.getDataByQuery(query, null)).thenReturn(basePolicyData);
 242             servlet.setPolicyController(controller);
 243             servlet.doPost(request, response);
 244         } catch (Exception e1) {
 245             logger.error("Exception Occured" + e1);
 246             fail();
 247         }
 248     }
 249
 250     @SuppressWarnings("static-access")
 251     @Test
 252     public void test05PolicyScopeList() {
 253         PolicyManagerServlet servlet = new PolicyManagerServlet();
 254         PolicyController controller = mock(PolicyController.class);
 255         List<String> list = new ArrayList<>();
 256         list.add("{params: { mode: 'LIST', path: '/', onlyFolders: false}}");
 257         list.add("{params: { mode: 'LIST', path: '/com', onlyFolders: false}}");
 258         for (int i = 0; i < list.size(); i++) {
 259             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 260             try {
 261                 when(request.getReader()).thenReturn(reader);
 262                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 263                 when(controller.getDataByQuery("from PolicyEditorScopes", null)).thenReturn(policyEditorScopes);
 264                 when(controller.getDataByQuery("from PolicyEditorScopes where SCOPENAME like :scopeName", null))
 265                         .thenReturn(policyEditorScopes);
 266                 when(controller.getDataByQuery("from PolicyVersion where POLICY_NAME like :scopeName", null))
 267                         .thenReturn(policyVersion);
 268                 servlet.setPolicyController(controller);
 269                 servlet.setTestUserId("Test");
 270                 servlet.doPost(request, response);
 271             } catch (Exception e1) {
 272                 logger.error("Exception Occured" + e1);
 273                 fail();
 274             }
 275         }
 276     }
 277
 278     @SuppressWarnings("static-access")
 279     @Test
 280     public void test06editBasePolicyTest() {
 281         PolicyManagerServlet servlet = new PolicyManagerServlet();
 282         PolicyController controller = mock(PolicyController.class);
 283         List<String> list = new ArrayList<>();
 284         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_SampleTest1206.1.xml', onlyFolders: false}}");
 285         for (int i = 0; i < list.size(); i++) {
 286             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 287             try {
 288                 when(request.getReader()).thenReturn(reader);
 289                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 290                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 291                         null)).thenReturn(basePolicyData);
 292                 servlet.setPolicyController(controller);
 293                 servlet.setTestUserId("Test");
 294                 servlet.doPost(request, response);
 295             } catch (Exception e1) {
 296                 logger.error("Exception Occured" + e1);
 297                 fail();
 298             }
 299         }
 300     }
 301
 302     @SuppressWarnings("static-access")
 303     @Test
 304     public void test07editBRMSParamPolicyTest() {
 305         List<Object> policyData = new ArrayList<>();
 306         String policyContent = "";
 307         String configData = "";
 308         try {
 309             ClassLoader classLoader = getClass().getClassLoader();
 310             policyContent =
 311                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 312             configData = IOUtils
 313                     .toString(classLoader.getResourceAsStream("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt"));
 314         } catch (Exception e1) {
 315             logger.error("Exception Occured" + e1);
 316         }
 317         PolicyEntity entity = new PolicyEntity();
 318         entity.setPolicyName("Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 319         entity.setPolicyData(policyContent);
 320         entity.setScope("com");
 321         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 322         configurationEntity.setConfigBody(configData);
 323         configurationEntity.setConfigType("OTHER");
 324         configurationEntity.setConfigurationName("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.txt");
 325         configurationEntity.setDescription("test");
 326         entity.setConfigurationData(configurationEntity);
 327         policyData.add(entity);
 328         PolicyManagerServlet servlet = new PolicyManagerServlet();
 329         PolicyController controller = mock(PolicyController.class);
 330         List<String> list = new ArrayList<>();
 331         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml',"
 332                 + " onlyFolders: false}}");
 333         for (int i = 0; i < list.size(); i++) {
 334             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 335             try {
 336                 when(request.getReader()).thenReturn(reader);
 337                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 338                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 339                         null)).thenReturn(policyData);
 340                 servlet.setPolicyController(controller);
 341                 servlet.setTestUserId("Test");
 342                 servlet.doPost(request, response);
 343             } catch (Exception e1) {
 344                 logger.error("Exception Occured" + e1);
 345                 fail();
 346             }
 347         }
 348     }
 349
 350     @SuppressWarnings("static-access")
 351     @Test
 352     public void test08editBRMSRawPolicyTest() {
 353         List<Object> policyData = new ArrayList<>();
 354         String policyContent = "";
 355         String configData = "";
 356         try {
 357             ClassLoader classLoader = getClass().getClassLoader();
 358             policyContent =
 359                     IOUtils.toString(classLoader.getResourceAsStream("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml"));
 360             configData =
 361                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt"));
 362         } catch (Exception e1) {
 363             logger.error("Exception Occured" + e1);
 364         }
 365         PolicyEntity entity = new PolicyEntity();
 366         entity.setPolicyName("Config_BRMS_Raw_TestBRMSRawPolicy.1.xml");
 367         entity.setPolicyData(policyContent);
 368         entity.setScope("com");
 369         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 370         configurationEntity.setConfigBody(configData);
 371         configurationEntity.setConfigType("OTHER");
 372         configurationEntity.setConfigurationName("com.Config_BRMS_Raw_TestBRMSRawPolicy.1.txt");
 373         configurationEntity.setDescription("test");
 374         entity.setConfigurationData(configurationEntity);
 375         policyData.add(entity);
 376         PolicyManagerServlet servlet = new PolicyManagerServlet();
 377         PolicyController controller = mock(PolicyController.class);
 378         List<String> list = new ArrayList<>();
 379         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_BRMS_Raw_TestBRMSRawPolicy.1.xml',"
 380                 + " onlyFolders: false}}");
 381         for (int i = 0; i < list.size(); i++) {
 382             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 383             try {
 384                 when(request.getReader()).thenReturn(reader);
 385                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 386                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 387                         null)).thenReturn(policyData);
 388                 servlet.setPolicyController(controller);
 389                 servlet.setTestUserId("Test");
 390                 servlet.doPost(request, response);
 391             } catch (Exception e1) {
 392                 logger.error("Exception Occured" + e1);
 393                 fail();
 394             }
 395         }
 396     }
 397
 398     @SuppressWarnings("static-access")
 399     @Test
 400     public void test09editClosedLoopFaultPolicyTest() {
 401         List<Object> policyData = new ArrayList<>();
 402         String policyContent = "";
 403         String configData = "";
 404         try {
 405             ClassLoader classLoader = getClass().getClassLoader();
 406             policyContent =
 407                     IOUtils.toString(classLoader.getResourceAsStream("Config_Fault_TestClosedLoopPolicy.1.xml"));
 408             configData =
 409                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_Fault_TestClosedLoopPolicy.1.json"));
 410         } catch (Exception e1) {
 411             logger.error("Exception Occured" + e1);
 412         }
 413         PolicyEntity entity = new PolicyEntity();
 414         entity.setPolicyName("Config_Fault_TestClosedLoopPolicy.1.xml");
 415         entity.setPolicyData(policyContent);
 416         entity.setScope("com");
 417         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 418         configurationEntity.setConfigBody(configData);
 419         configurationEntity.setConfigType("JSON");
 420         configurationEntity.setConfigurationName("com.Config_Fault_TestClosedLoopPolicy.1.json");
 421         configurationEntity.setDescription("test");
 422         entity.setConfigurationData(configurationEntity);
 423         policyData.add(entity);
 424         PolicyManagerServlet servlet = new PolicyManagerServlet();
 425         PolicyController controller = mock(PolicyController.class);
 426         List<String> list = new ArrayList<>();
 427         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_Fault_TestClosedLoopPolicy.1.xml',"
 428                 + " onlyFolders: false}}");
 429         for (int i = 0; i < list.size(); i++) {
 430             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 431             try {
 432                 when(request.getReader()).thenReturn(reader);
 433                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 434                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 435                         null)).thenReturn(policyData);
 436                 servlet.setPolicyController(controller);
 437                 servlet.setTestUserId("Test");
 438                 servlet.doPost(request, response);
 439             } catch (Exception e1) {
 440                 logger.error("Exception Occured" + e1);
 441                 fail();
 442             }
 443         }
 444     }
 445
 446     @SuppressWarnings("static-access")
 447     @Test
 448     public void test10editClosedLoopPMPolicyTest() {
 449         List<Object> policyData = new ArrayList<>();
 450         String policyContent = "";
 451         String configData = "";
 452         try {
 453             ClassLoader classLoader = getClass().getClassLoader();
 454             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_PM_TestClosedLoopPMPolicy.1.xml"));
 455             configData =
 456                     IOUtils.toString(classLoader.getResourceAsStream("com.Config_PM_TestClosedLoopPMPolicy.1.json"));
 457         } catch (Exception e1) {
 458             logger.error("Exception Occured" + e1);
 459         }
 460         PolicyEntity entity = new PolicyEntity();
 461         entity.setPolicyName("Config_PM_TestClosedLoopPMPolicy.1.xml");
 462         entity.setPolicyData(policyContent);
 463         entity.setScope("com");
 464         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 465         configurationEntity.setConfigBody(configData);
 466         configurationEntity.setConfigType("JSON");
 467         configurationEntity.setConfigurationName("com.Config_PM_TestClosedLoopPMPolicy.1.json");
 468         configurationEntity.setDescription("test");
 469         entity.setConfigurationData(configurationEntity);
 470         policyData.add(entity);
 471         PolicyManagerServlet servlet = new PolicyManagerServlet();
 472         PolicyController controller = mock(PolicyController.class);
 473         List<String> list = new ArrayList<>();
 474         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_PM_TestClosedLoopPMPolicy.1.xml',"
 475                 + " onlyFolders: false}}");
 476         for (int i = 0; i < list.size(); i++) {
 477             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 478             try {
 479                 when(request.getReader()).thenReturn(reader);
 480                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 481                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 482                         null)).thenReturn(policyData);
 483                 servlet.setPolicyController(controller);
 484                 servlet.setTestUserId("Test");
 485                 servlet.doPost(request, response);
 486             } catch (Exception e1) {
 487                 logger.error("Exception Occured" + e1);
 488                 fail();
 489             }
 490         }
 491     }
 492
 493     @SuppressWarnings("static-access")
 494     @Test
 495     public void test11editMicroServicePolicyTest() {
 496         GroupPolicyScopeList groupData = new GroupPolicyScopeList();
 497         groupData.setGroupName("Test");
 498         groupData.setGroupList("resource=SampleResource,service=SampleService,type=SampleType,"
 499                 + "closedLoopControlName=SampleClosedLoop");
 500         List<Object> groupListData = new ArrayList<>();
 501         groupListData.add(groupData);
 502         commonClassDao = mock(CommonClassDao.class);
 503         CreateDcaeMicroServiceController.setCommonClassDao(commonClassDao);
 504         List<Object> policyData = new ArrayList<>();
 505         String policyContent = "";
 506         String configData = "";
 507         try {
 508             ClassLoader classLoader = getClass().getClassLoader();
 509             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_MS_vFirewall.1.xml"));
 510             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_MS_vFirewall.1.json"));
 511         } catch (Exception e1) {
 512             logger.error("Exception Occured" + e1);
 513         }
 514         PolicyEntity entity = new PolicyEntity();
 515         entity.setPolicyName("Config_MS_vFirewall.1.xml");
 516         entity.setPolicyData(policyContent);
 517         entity.setScope("com");
 518         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 519         configurationEntity.setConfigBody(configData);
 520         configurationEntity.setConfigType("JSON");
 521         configurationEntity.setConfigurationName("com.Config_MS_vFirewall.1.json");
 522         configurationEntity.setDescription("test");
 523         entity.setConfigurationData(configurationEntity);
 524         policyData.add(entity);
 525         PolicyManagerServlet servlet = new PolicyManagerServlet();
 526         PolicyController controller = mock(PolicyController.class);
 527         List<String> list = new ArrayList<>();
 528         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_MS_vFirewall.1.xml', onlyFolders: false}}");
 529         for (int i = 0; i < list.size(); i++) {
 530             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 531             try {
 532                 when(request.getReader()).thenReturn(reader);
 533                 when(commonClassDao.getDataById(GroupPolicyScopeList.class, "groupList",
 534                         "resource=SampleResource,service=SampleService,type=SampleType,"
 535                                 + "closedLoopControlName=SampleClosedLoop")).thenReturn(groupListData);
 536                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 537                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 538                         null)).thenReturn(policyData);
 539                 servlet.setPolicyController(controller);
 540                 servlet.setTestUserId("Test");
 541                 servlet.doPost(request, response);
 542             } catch (Exception e1) {
 543                 logger.error("Exception Occured" + e1);
 544                 fail();
 545             }
 546         }
 547     }
 548
 549     @SuppressWarnings("static-access")
 550     @Test
 551     public void test12editFirewallPolicyTest() {
 552         List<Object> policyData = new ArrayList<>();
 553         String policyContent = "";
 554         String configData = "";
 555         try {
 556             ClassLoader classLoader = getClass().getClassLoader();
 557             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Config_FW_TestFireWallPolicy.1.xml"));
 558             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Config_FW_TestFireWallPolicy.1.json"));
 559         } catch (Exception e1) {
 560             logger.error("Exception Occured" + e1);
 561         }
 562         PolicyEntity entity = new PolicyEntity();
 563         entity.setPolicyName("Config_FW_TestFireWallPolicy.1.xml");
 564         entity.setPolicyData(policyContent);
 565         entity.setScope("com");
 566         ConfigurationDataEntity configurationEntity = new ConfigurationDataEntity();
 567         configurationEntity.setConfigBody(configData);
 568         configurationEntity.setConfigType("JSON");
 569         configurationEntity.setConfigurationName("com.Config_FW_TestFireWallPolicy.1.json");
 570         configurationEntity.setDescription("test");
 571         entity.setConfigurationData(configurationEntity);
 572         policyData.add(entity);
 573         PolicyManagerServlet servlet = new PolicyManagerServlet();
 574         PolicyController controller = mock(PolicyController.class);
 575         List<String> list = new ArrayList<>();
 576         list.add("{params: { mode: 'EDITFILE', path: '/com/Config_FW_TestFireWallPolicy.1.xml',"
 577                 + " onlyFolders: false}}");
 578         for (int i = 0; i < list.size(); i++) {
 579             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 580             try {
 581                 when(request.getReader()).thenReturn(reader);
 582                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 583                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 584                         null)).thenReturn(policyData);
 585                 servlet.setPolicyController(controller);
 586                 servlet.setTestUserId("Test");
 587                 servlet.doPost(request, response);
 588             } catch (Exception e1) {
 589                 logger.error("Exception Occured" + e1);
 590                 fail();
 591             }
 592         }
 593     }
 594
 595     @SuppressWarnings("static-access")
 596     @Test
 597     public void test13editActionPolicyTest() {
 598         List<Object> policyData = new ArrayList<>();
 599         String policyContent = "";
 600         String configData = "";
 601         try {
 602             ClassLoader classLoader = getClass().getClassLoader();
 603             policyContent = IOUtils.toString(classLoader.getResourceAsStream("Action_TestActionPolicy.1.xml"));
 604             configData = IOUtils.toString(classLoader.getResourceAsStream("com.Action_TestActionPolicy.1.json"));
 605         } catch (Exception e1) {
 606             logger.error("Exception Occured" + e1);
 607         }
 608         PolicyEntity entity = new PolicyEntity();
 609         entity.setPolicyName("Action_TestActionPolicy.1.xml");
 610         entity.setPolicyData(policyContent);
 611         entity.setScope("com");
 612         ActionBodyEntity configurationEntity = new ActionBodyEntity();
 613         configurationEntity.setActionBody(configData);
 614         configurationEntity.setActionBodyName("com.Action_TestActionPolicy.1.json");
 615         entity.setActionBodyEntity(configurationEntity);
 616         policyData.add(entity);
 617         PolicyManagerServlet servlet = new PolicyManagerServlet();
 618         PolicyController controller = mock(PolicyController.class);
 619         List<String> list = new ArrayList<>();
 620         list.add("{params: { mode: 'EDITFILE', path: '/com/Action_TestActionPolicy.1.xml'," + " onlyFolders: false}}");
 621         for (int i = 0; i < list.size(); i++) {
 622             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 623             try {
 624                 when(request.getReader()).thenReturn(reader);
 625                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 626                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 627                         null)).thenReturn(policyData);
 628                 servlet.setPolicyController(controller);
 629                 servlet.setTestUserId("Test");
 630                 servlet.doPost(request, response);
 631             } catch (Exception e1) {
 632                 logger.error("Exception Occured" + e1);
 633                 fail();
 634             }
 635         }
 636     }
 637
 638     @SuppressWarnings("static-access")
 639     @Test
 640     public void test14editDecisionPolicyTest() {
 641         List<Object> policyData = new ArrayList<>();
 642         String policyContent = "";
 643         try {
 644             ClassLoader classLoader = getClass().getClassLoader();
 645             policyContent = IOUtils
 646                     .toString(classLoader.getResourceAsStream("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml"));
 647         } catch (Exception e1) {
 648             logger.error("Exception Occured" + e1);
 649         }
 650         PolicyEntity entity = new PolicyEntity();
 651         entity.setPolicyName("Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml");
 652         entity.setPolicyData(policyContent);
 653         entity.setScope("com");
 654         policyData.add(entity);
 655         PolicyManagerServlet servlet = new PolicyManagerServlet();
 656         PolicyController controller = mock(PolicyController.class);
 657         List<String> list = new ArrayList<>();
 658         list.add("{params: { mode: 'EDITFILE', path: '/com/Decision_TestDecisionPolicyWithRuleAlgorithms.1.xml',"
 659                 + " onlyFolders: false}}");
 660         for (int i = 0; i < list.size(); i++) {
 661             BufferedReader reader = new BufferedReader(new StringReader(list.get(i)));
 662             try {
 663                 when(request.getReader()).thenReturn(reader);
 664                 when(controller.getRoles("Test")).thenReturn(rolesdata);
 665                 when(controller.getDataByQuery("FROM PolicyEntity where policyName = :split_1 and scope = :split_0",
 666                         null)).thenReturn(policyData);
 667                 servlet.setPolicyController(controller);
 668                 servlet.setTestUserId("Test");
 669                 servlet.doPost(request, response);
 670             } catch (Exception e1) {
 671                 logger.error("Exception Occured" + e1);
 672                 fail();
 673             }
 674         }
 675     }
 676
 677     @Test
 678     public void test15AddScope() {
 679         PolicyManagerServlet servlet = new PolicyManagerServlet();
 680         PolicyController controller = mock(PolicyController.class);
 681         List<BufferedReader> readers = new ArrayList<>();
 682         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test'}}")));
 683         readers.add(new BufferedReader(new StringReader("{params: { mode: 'ADDFOLDER', path: '/', name: 'Test*&'}}")));
 684         readers.add(new BufferedReader(
 685                 new StringReader("{params: { mode: 'ADDFOLDER', path: '/Test', subScopename: 'Test1'}}")));
 686         for (int i = 0; i < readers.size(); i++) {
 687             try {
 688                 when(request.getReader()).thenReturn(readers.get(i));
 689                 PolicyManagerServlet.setPolicyController(controller);
 690                 servlet.doPost(request, response);
 691                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 692             } catch (Exception e1) {
 693                 logger.error("Exception Occured" + e1);
 694                 fail();
 695             }
 696         }
 697     }
 698
 699     @Test
 700     public void test16Clone() {
 701         PolicyManagerServlet servlet = new PolicyManagerServlet();
 702         PolicyController controller = mock(PolicyController.class);
 703         List<BufferedReader> readers = new ArrayList<>();
 704         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
 705                 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 706         when(controller.getDataByQuery(
 707                 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
 708                         .thenReturn(basePolicyData);
 709         readers.add(new BufferedReader(new StringReader("{params: { mode: 'COPY', path: 'com.Config_test.1.xml',"
 710                 + " newPath: 'com.Config_testClone.1.xml'}}")));
 711         for (int i = 0; i < readers.size(); i++) {
 712             try {
 713                 when(request.getReader()).thenReturn(readers.get(i));
 714                 PolicyManagerServlet.setPolicyController(controller);
 715                 servlet.doPost(request, response);
 716                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 717             } catch (Exception e1) {
 718                 logger.error("Exception Occured" + e1);
 719                 fail();
 720             }
 721         }
 722     }
 723
 724     @Test
 725     public void test17Rename() {
 726         PolicyManagerServlet servlet = new PolicyManagerServlet();
 727         PolicyController controller = mock(PolicyController.class);
 728         List<BufferedReader> readers = new ArrayList<>();
 729         when(controller.getEntityItem(ConfigurationDataEntity.class, "configurationName",
 730                 "com.Config_SampleTest1206.1.txt")).thenReturn(configurationEntity);
 731         when(controller.getDataByQuery(
 732                 "FROM PolicyEntity where policyName = :oldPolicySplit_1 and scope = :oldPolicySplit_0", null))
 733                         .thenReturn(basePolicyData);
 734         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com.Config_test.1.xml',"
 735                 + " newPath: 'com.Config_testClone.1.xml'}}")));
 736         for (int i = 0; i < readers.size(); i++) {
 737             try {
 738                 when(request.getReader()).thenReturn(readers.get(i));
 739                 PolicyManagerServlet.setPolicyController(controller);
 740                 servlet.doPost(request, response);
 741                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 742             } catch (Exception e1) {
 743                 logger.error("Exception Occured" + e1);
 744                 fail();
 745             }
 746         }
 747     }
 748
 749     @Test
 750     public void test18RenameScope() throws Exception {
 751         PolicyManagerServlet servlet = new PolicyManagerServlet();
 752         PolicyController controller = mock(PolicyController.class);
 753         List<BufferedReader> readers = new ArrayList<>();
 754         readers.add(new BufferedReader(new StringReader("{params: { mode: 'RENAME', path: 'com', newPath: 'Test'}}")));
 755         for (int i = 0; i < readers.size(); i++) {
 756             try {
 757                 when(request.getReader()).thenReturn(readers.get(i));
 758                 PolicyManagerServlet.setPolicyController(controller);
 759                 servlet.doPost(request, response);
 760                 assertTrue(response.getContentAsString() != null && response.getContentAsString().contains("success"));
 761             } catch (Exception e1) {
 762                 logger.error("Exception Occured" + e1);
 763                 fail();
 764             }
 765         }
 766
 767         String inScopeName = "\\\\\\\\inScopeName";
 768         String newScopeName = "\\\\\\\\newScopeName";
 769         List<Object> scopesList = new ArrayList<Object>();
 770         PolicyEditorScopes mockPolicyEditorScope = Mockito.mock(PolicyEditorScopes.class);
 771         scopesList.add(mockPolicyEditorScope);
 772         when(mockPolicyEditorScope.getScopeName()).thenReturn("inScopeName");
 773         Whitebox.invokeMethod(servlet, "renameScope", scopesList, inScopeName, newScopeName, controller);
 774         verify(mockPolicyEditorScope, atLeast(1)).getScopeName();
 775     }
 776
 777     @Test
 778     public void test19SetPolicyNames() {
 779         JsonArray mockJsonArray = Mockito.mock(JsonArray.class);
 780         PolicyManagerServlet.setPolicyNames(mockJsonArray);
 781         assertEquals(mockJsonArray, PolicyManagerServlet.getPolicyNames());
 782     }
 783
 784     @Test
 785     public void test20DoPostSetErrorException() throws IOException {
 786         PolicyManagerServlet servlet = new PolicyManagerServlet();
 787         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 788         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 789         doThrow(IOException.class).when(mockRequest).getReader();
 790         doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
 791         servlet.doPost(mockRequest, mockResponse);
 792         verify(mockRequest).getReader();
 793     }
 794
 795     @Test
 796     public void test21DoPostException() throws IOException {
 797         PolicyManagerServlet servlet = new PolicyManagerServlet();
 798         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 799         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 800
 801         doThrow(IOException.class).when(mockRequest).getReader();
 802         doThrow(IOException.class).when(mockResponse).sendError(any(Integer.class), any(String.class));
 803         doThrow(IOException.class).when(mockResponse).getWriter();
 804
 805         servlet.doPost(mockRequest, mockResponse);
 806         verify(mockRequest).getReader();
 807         verify(mockResponse).getWriter();
 808     }
 809
 810     @Test
 811     public void test22DoPostSuccess() throws IOException {
 812         PolicyManagerServlet servlet = new PolicyManagerServlet();
 813         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 814         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 815         PrintWriter mockPrintWriter = Mockito.mock(PrintWriter.class);
 816
 817         doThrow(IOException.class).when(mockRequest).getReader();
 818         when(mockResponse.getWriter()).thenReturn(mockPrintWriter);
 819
 820         servlet.doPost(null, mockResponse);
 821         verify(mockResponse).getWriter();
 822     }
 823
 824     @Test
 825     public void test23DoPostUploadFileException() {
 826         PolicyManagerServlet servlet = new PolicyManagerServlet() {
 827             private static final long serialVersionUID = 1L;
 828             @Override
 829             protected boolean isMultipartContent(HttpServletRequest request) {
 830                 return true;
 831             }
 832         };
 833         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 834         HttpServletResponse mockResponse = Mockito.mock(HttpServletResponse.class);
 835         servlet.doPost(mockRequest, mockResponse);
 836     }
 837
 838     @Test
 839     public void test24ProcessFormFile() throws Exception {
 840         long fileSizeLimit = 10;
 841
 842         PolicyManagerServlet servlet = new PolicyManagerServlet() {
 843             private static final long serialVersionUID = 1L;
 844
 845             @Override
 846             protected long getFileSizeLimit() {
 847                 return fileSizeLimit;
 848             }
 849
 850             @Override
 851             protected long copyStream(InputStream inputStream, OutputStream outputStream) throws IOException {
 852                 // don't really copy the file
 853                 return 0;
 854             }
 855         };
 856         HttpServletRequest mockRequest = Mockito.mock(HttpServletRequest.class);
 857         HttpServletResponse mockResp = Mockito.mock(HttpServletResponse.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, mockResp);
 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, mockResp);
 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, mockResp);
 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 }