POLICY-SDK-APP/src/test/java/org/onap/policy/admin/PolicyManagerServletTest.java

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