ONAP-PAP-REST/src/test/java/org/onap/policy/pap/test/XACMLPAPTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2018 Samsung Electronics Co., Ltd.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.pap.test;
  23
  24 import static org.junit.Assert.assertTrue;
  25 import static org.junit.Assert.fail;
  26 import static org.mockito.Mockito.when;
  27
  28 import com.mockrunner.mock.web.MockServletInputStream;
  29
  30 import java.io.BufferedReader;
  31 import java.io.IOException;
  32 import java.io.InputStreamReader;
  33 import java.sql.SQLException;
  34 import java.util.ArrayList;
  35 import java.util.Arrays;
  36 import java.util.Collections;
  37 import java.util.HashMap;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Properties;
  41
  42 import javax.servlet.ServletConfig;
  43 import javax.servlet.ServletException;
  44 import javax.servlet.ServletOutputStream;
  45 import javax.servlet.http.HttpServletRequest;
  46 import javax.servlet.http.HttpServletResponse;
  47
  48 import org.apache.commons.logging.Log;
  49 import org.apache.commons.logging.LogFactory;
  50 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
  51 import org.hibernate.SessionFactory;
  52 import org.junit.AfterClass;
  53 import org.junit.Before;
  54 import org.junit.BeforeClass;
  55 import org.junit.Test;
  56 import org.mockito.Mockito;
  57 import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
  58 import org.onap.policy.pap.xacml.rest.components.FirewallConfigPolicy;
  59 import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTest;
  60 import org.onap.policy.pap.xacml.rest.controller.ActionPolicyDictionaryController;
  61 import org.onap.policy.pap.xacml.rest.controller.ClosedLoopDictionaryController;
  62 import org.onap.policy.pap.xacml.rest.controller.DecisionPolicyDictionaryController;
  63 import org.onap.policy.pap.xacml.rest.controller.DescriptiveDictionaryController;
  64 import org.onap.policy.pap.xacml.rest.controller.DictionaryController;
  65 import org.onap.policy.pap.xacml.rest.controller.FirewallDictionaryController;
  66 import org.onap.policy.pap.xacml.rest.controller.MicroServiceDictionaryController;
  67 import org.onap.policy.pap.xacml.rest.controller.PolicyScopeDictionaryController;
  68 import org.onap.policy.pap.xacml.rest.controller.SafePolicyController;
  69 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
  70 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
  71 import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
  72 import org.onap.policy.rest.dao.CommonClassDao;
  73 import org.onap.policy.rest.jpa.ActionPolicyDict;
  74 import org.onap.policy.rest.jpa.BRMSParamTemplate;
  75 import org.onap.policy.rest.jpa.Category;
  76 import org.onap.policy.rest.jpa.FunctionDefinition;
  77 import org.onap.policy.rest.jpa.PolicyEditorScopes;
  78 import org.onap.policy.rest.jpa.UserInfo;
  79 import org.onap.policy.utils.PolicyUtils;
  80 import org.onap.policy.xacml.std.pap.StdPAPPolicy;
  81 import org.onap.policy.xacml.std.pap.StdPAPPolicyParams;
  82 import org.springframework.mock.web.MockHttpServletResponse;
  83 import org.springframework.mock.web.MockServletConfig;
  84 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
  85
  86 public class XACMLPAPTest {
  87     private static final Log logger = LogFactory.getLog(XACMLPAPTest.class);
  88
  89     private static final String ENVIRONMENT_HEADER = "Environment";
  90     private static List<String> headers = new ArrayList<>();
  91     private HttpServletRequest httpServletRequest;
  92     private HttpServletResponse httpServletResponse;
  93     private ServletOutputStream mockOutput;
  94     private static ServletConfig servletConfig;
  95     private static XACMLPapServlet pap;
  96     private static SessionFactory sessionFactory;
  97     private static CommonClassDao commonClassDao;
  98
  99     @BeforeClass
 100     public static void beforeClassSetup() throws ServletException {
 101         sessionFactory = PolicyDBDaoTest.setupH2DbDaoImpl("xacmlpaptest");
 102         new FirewallConfigPolicy(new CommonClassDaoImpl());
 103         new DictionaryUtils(new CommonClassDaoImpl());
 104         setUp();
 105     }
 106
 107     public static void setUp() throws ServletException {
 108         servletConfig = Mockito.mock(MockServletConfig.class);
 109         System.setProperty("com.sun.management.jmxremote.port", "9993");
 110         Mockito.when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
 111         Mockito.when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME"))
 112                 .thenReturn("src/test/resources/xacml.pap.properties");
 113         pap = new XACMLPapServlet();
 114         pap.init(servletConfig);
 115         commonClassDao = Mockito.mock(CommonClassDao.class);
 116         new DictionaryUtils(commonClassDao);
 117         DictionaryUtils.setDictionaryUtils(new DictionaryUtils());
 118         UserInfo user = new UserInfo();
 119         user.setUserLoginId("API");
 120         user.setUserName("API");
 121         Mockito.when(commonClassDao.getEntityItem(UserInfo.class, "userLoginId", "API")).thenReturn(user);
 122         Mockito.mock(DictionaryUtils.class);
 123     }
 124
 125     @Before
 126     public void testInit() {
 127         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 128         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 129         logger.info(httpServletResponse);
 130         Mockito.when(httpServletRequest.getHeaderNames()).thenReturn(Collections.enumeration(headers));
 131         Mockito.when(httpServletRequest.getAttributeNames()).thenReturn(Collections.enumeration(headers));
 132         CommonClassDaoImpl.setSessionfactory(sessionFactory);
 133         PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
 134     }
 135
 136     @Test
 137     public void testFirwallCreatePolicy() throws IOException, ServletException, SQLException {
 138         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 139         String json = "{\"serviceTypeId\":\"/v0/firewall/pan\",\"configName\":\"TestFwPolicyConfig\","
 140                 + "\"deploymentOption\":{\"deployNow\":false},\"securityZoneId\":\"cloudsite:dev1a\","
 141                 + "\"serviceGroups\":[{\"name\":\"SSH\",\"description\":\"Sshservice entry in servicelist\","
 142                 + "\"type\":\"SERVICE\",\"transportProtocol\":\"tcp\",\"appProtocol\":null,\"ports\":\"22\"}],"
 143                 + "\"addressGroups\":[{\"name\":\"test\",\"description\":\"Destination\","
 144                 + "\"members\":[{\"type\":\"SUBNET\",\"value\":\"127.0.0.1/12\"}]},{\"name\":\"TestServers\","
 145                 + "\"description\":\"SourceTestServers for firsttesting\",\"members\":[{\"type\":\"SUBNET\","
 146                 + "\"value\":\"127.0.0.1/23\"}]}],\"firewallRuleList\":[{\"position\":\"1\","
 147                 + "\"ruleName\":\"FWRuleTestServerToTest\",\"fromZones\":[\"UntrustedZoneTestName\"],"
 148                 + "\"toZones\":[\"TrustedZoneTestName\"],\"negateSource\":false,\"negateDestination\":false,"
 149                 + "\"sourceList\":[{\"type\":\"REFERENCE\",\"name\":\"TestServers\"}],"
 150                 + "\"destinationList\":[{\"type\":\"REFERENCE\",\"name\":\"Test\"}],\"sourceServices\":[],"
 151                 + "\"destServices\":[{\"type\":\"REFERENCE\",\"name\":\"SSH\"}],\"action\":\"accept\","
 152                 + "\"description\":\"FWrule for Test source to Test destination\",\"enabled\":true,"
 153                 + "\"log\":true}]}";
 154         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 155         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 156         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 157         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 158         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
 159         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("Firewall Config")
 160                 .policyName("test").description("testDescription").configName("Test").editPolicy(false).domain("test")
 161                 .jsonBody(json).highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate("")
 162                 .build());
 163         MockServletInputStream mockInput =
 164                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 165         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 166         logger.info(httpServletRequest);
 167         logger.info(httpServletResponse);
 168         pap.service(httpServletRequest, httpServletResponse);
 169         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 170     }
 171
 172     @Test
 173     public void testBRMSCreatePolicy() throws IOException, ServletException, SQLException {
 174         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 175         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 176         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 177         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 178         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 179         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
 180         Map<String, String> matchingAttributes = new HashMap<>();
 181         Map<String, String> ruleAttributes = new HashMap<>();
 182         ruleAttributes.put("templateName", "testPolicy");
 183         ruleAttributes.put("samPoll", "5");
 184         ruleAttributes.put("value", "test");
 185         // Creating BRMS Param Policies from the Admin Console
 186         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Param")
 187                 .policyName("test").description("testing").configName("BRMS_PARAM_RULE").editPolicy(false)
 188                 .domain("test").dynamicFieldConfigAttributes(matchingAttributes).highestVersion(0).onapName("DROOLS")
 189                 .configBodyData(null).drlRuleAndUIParams(ruleAttributes).riskLevel("5").riskType("default")
 190                 .guard("false").ttlDate("").brmsController(null).brmsDependency(null).build());
 191         MockServletInputStream mockInput =
 192                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 193         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 194
 195         setPolicyCreation();
 196         logger.info(httpServletRequest);
 197         logger.info(httpServletResponse);
 198         pap.service(httpServletRequest, httpServletResponse);
 199         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 200     }
 201
 202     @Test
 203     public void testBRMSRawCreatePolicy() throws IOException, ServletException, SQLException {
 204         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 205         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 206         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 207         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 208         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 209         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
 210         Map<String, String> ruleAttributes = new HashMap<>();
 211         ruleAttributes.put("value", "test");
 212         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Raw")
 213                 .policyName("test").description("testig description").configName("BRMS_RAW_RULE").editPolicy(false)
 214                 .domain("test").dynamicFieldConfigAttributes(ruleAttributes).highestVersion(0).onapName("DROOLS")
 215                 .configBodyData("test").riskLevel("4").riskType("default").guard("false").build());
 216         MockServletInputStream mockInput =
 217                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 218         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 219
 220         setPolicyCreation();
 221         logger.info(httpServletRequest);
 222         logger.info(httpServletResponse);
 223         pap.service(httpServletRequest, httpServletResponse);
 224         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 225     }
 226
 227     @Test
 228     public void testClosedLoopPMCreatePolicy() throws IOException, ServletException, SQLException {
 229         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 230         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 231         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 232         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 233         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 234         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
 235         String json = "{\"test\":\"java\"}";
 236         // Creating CloseLoop_Fault and Performance Metric Policies
 237         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("ClosedLoop_PM")
 238                 .policyName("test").description("testing").onapName("onap").jsonBody(json).draft(false)
 239                 .oldPolicyFileName(null).serviceType("Registration Failure(Trinity)").editPolicy(false).domain("test")
 240                 .highestVersion(0).riskLevel(null).riskType("default").guard("true").ttlDate("").build());
 241         MockServletInputStream mockInput =
 242                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 243         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 244
 245         setPolicyCreation();
 246         logger.info(httpServletRequest);
 247         logger.info(httpServletResponse);
 248         pap.service(httpServletRequest, httpServletResponse);
 249         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 250     }
 251
 252     @Test
 253     public void testDecisonAAFPolicy() throws IOException, ServletException, SQLException {
 254         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 255         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 256         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 257         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 258         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 259         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
 260         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
 261                 StdPAPPolicyParams.builder().policyName("test").description("test rule").onapName("ONAP")
 262                         .providerComboBox("AAF").editPolicy(false).domain("test").highestVersion(0).build());
 263         MockServletInputStream mockInput =
 264                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 265         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 266
 267         logger.info(httpServletRequest);
 268         logger.info(httpServletResponse);
 269         pap.service(httpServletRequest, httpServletResponse);
 270         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 271     }
 272
 273     @Test
 274     public void testDecisonGuardPolicy() throws IOException, ServletException, SQLException {
 275         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 276         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 277         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 278         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 279         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 280         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
 281         Map<String, String> matchingAttributes = new HashMap<>();
 282         matchingAttributes.put("actor", "test");
 283         matchingAttributes.put("recipe", "restart");
 284         matchingAttributes.put("targets", "test,test1");
 285         matchingAttributes.put("clname", "");
 286         matchingAttributes.put("limit", "1");
 287         matchingAttributes.put("timeWindow", "15");
 288         matchingAttributes.put("timeUnits", "minute");
 289         matchingAttributes.put("guardActiveStart", "05:00");
 290         matchingAttributes.put("guardActiveEnd", "10:00");
 291         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
 292                 StdPAPPolicyParams.builder().policyName("testGuard").description("test rule").onapName("PDPD")
 293                         .providerComboBox("GUARD_YAML").dynamicFieldConfigAttributes(matchingAttributes)
 294                         .editPolicy(false).domain("test").highestVersion(0).build());
 295         MockServletInputStream mockInput =
 296                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 297         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 298
 299         logger.info(httpServletRequest);
 300         logger.info(httpServletResponse);
 301         pap.service(httpServletRequest, httpServletResponse);
 302         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 303     }
 304
 305     @Test
 306     public void testDecisonGuardMinMaxPolicy() throws IOException, ServletException, SQLException {
 307         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 308         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 309         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 310         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 311         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 312         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
 313         Map<String, String> matchingAttributes = new HashMap<>();
 314         matchingAttributes.put("actor", "test");
 315         matchingAttributes.put("recipe", "scaleOut");
 316         matchingAttributes.put("targets", "test,test1");
 317         matchingAttributes.put("clname", "test");
 318         matchingAttributes.put("min", "1");
 319         matchingAttributes.put("max", "5");
 320         matchingAttributes.put("guardActiveStart", "05:00");
 321         matchingAttributes.put("guardActiveEnd", "10:00");
 322         StdPAPPolicy newPAPPolicy =
 323
 324                 new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("testGuardMinMax").description("test rule")
 325                         .onapName("PDPD").providerComboBox("GUARD_MIN_MAX")
 326                         .dynamicFieldConfigAttributes(matchingAttributes).editPolicy(false).domain("test")
 327                         .highestVersion(0).build());
 328         MockServletInputStream mockInput =
 329                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 330         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 331
 332         logger.info(httpServletRequest);
 333         logger.info(httpServletResponse);
 334         pap.service(httpServletRequest, httpServletResponse);
 335         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 336     }
 337
 338     @Test
 339     public void testDecisonBLGuardPolicy() throws IOException, ServletException, SQLException {
 340         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 341         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 342         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 343         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 344         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 345         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
 346         Map<String, String> matchingAttributes = new HashMap<>();
 347         matchingAttributes.put("actor", "test");
 348         matchingAttributes.put("recipe", "restart");
 349         matchingAttributes.put("clname", "test");
 350         matchingAttributes.put("guardActiveStart", "05:00");
 351         matchingAttributes.put("guardActiveEnd", "10:00");
 352         matchingAttributes.put("blackList", "bl1,bl2");
 353         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
 354                 StdPAPPolicyParams.builder().policyName("testblGuard").description("test rule").onapName("PDPD")
 355                         .providerComboBox("GUARD_BL_YAML").dynamicFieldConfigAttributes(matchingAttributes)
 356                         .editPolicy(false).domain("test").highestVersion(0).build());
 357         MockServletInputStream mockInput =
 358                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 359         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 360
 361         logger.info(httpServletRequest);
 362         logger.info(httpServletResponse);
 363         pap.service(httpServletRequest, httpServletResponse);
 364         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 365     }
 366
 367     @Test
 368     public void testConfigPolicy() throws IOException, ServletException, SQLException {
 369         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 370         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 371         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 372         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 373         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 374         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
 375         Map<String, String> configAttributes = new HashMap<>();
 376         configAttributes.put("value", "test");
 377         StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
 378                 StdPAPPolicyParams.builder().configPolicyType("Base").policyName("test").description("test rule")
 379                         .onapName("TEST").configName("config").dynamicFieldConfigAttributes(configAttributes)
 380                         .configType("OTHER").configBodyData("test body").editPolicy(false).domain("test")
 381                         .highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate(null).build());
 382         MockServletInputStream mockInput =
 383                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
 384         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 385
 386         logger.info(httpServletRequest);
 387         logger.info(httpServletResponse);
 388         pap.service(httpServletRequest, httpServletResponse);
 389         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 390     }
 391
 392     @Test
 393     public void testActionPolicy() throws IOException, ServletException, SQLException {
 394         setPolicyCreation();
 395         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 396         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 397         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 398         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("API");
 399         Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 400         Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Action");
 401
 402         CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
 403         PolicyCreation.setCommonClassDao(commonClassDao);
 404         ActionPolicyDict actionDict = new ActionPolicyDict();
 405         actionDict.setBody("{\"test\":\"test\"}");
 406         actionDict.setHeader("test122=test12:test22=test34");
 407         actionDict.setType("REST");
 408         actionDict.setMethod("GET");
 409         actionDict.setUrl("testsomeurl.com");
 410         Mockito.when(commonClassDao.getEntityItem(ActionPolicyDict.class, "attributeName", "test"))
 411                 .thenReturn(actionDict);
 412         FunctionDefinition funcDefn = new FunctionDefinition();
 413         funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:and");
 414         Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "and")).thenReturn(funcDefn);
 415         funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-equal");
 416         Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-equal"))
 417                 .thenReturn(funcDefn);
 418         funcDefn.setXacmlid("urn:oasis:names:tc:xacml:3.0:function:string-contains");
 419         Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "string-contains"))
 420                 .thenReturn(funcDefn);
 421         funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-greater-than");
 422         Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-greater-than"))
 423                 .thenReturn(funcDefn);
 424         funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:or");
 425         Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "or")).thenReturn(funcDefn);
 426
 427         Map<String, String> componentAttributes = new HashMap<>();
 428         componentAttributes.put("java", "test");
 429         StdPAPPolicy newPapPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("test").description("test")
 430                 .dynamicFieldConfigAttributes(componentAttributes)
 431                 .dynamicRuleAlgorithmLabels(Arrays.asList("A1", "A2", "A3", "A4", "A5", "A6", "A7"))
 432                 .dynamicRuleAlgorithmCombo(Arrays.asList("integer-equal", "string-contains", "integer-equal", "and",
 433                         "integer-greater-than", "or", "and"))
 434                 .dynamicRuleAlgorithmField1(Arrays.asList("cobal", "cap", "cobal", "A2", "Config", "A4", "A1"))
 435                 .dynamicRuleAlgorithmField2(Arrays.asList("90", "ca", "90", "A3", "45", "A5", "A6"))
 436                 .actionPerformer("PDP").actionAttribute("test").editPolicy(false).domain("com").highestVersion(0)
 437                 .build());
 438         newPapPolicy.setActionBody("{\"test\":\"test\"}");
 439
 440         MockServletInputStream mockInput =
 441                 new MockServletInputStream(PolicyUtils.objectToJsonString(newPapPolicy).getBytes());
 442         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 443
 444         logger.info(httpServletRequest);
 445         logger.info(httpServletResponse);
 446         pap.service(httpServletRequest, httpServletResponse);
 447         Mockito.verify(httpServletResponse).addHeader("operation", "create");
 448     }
 449
 450     private void setPolicyCreation() {
 451         CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
 452         PolicyCreation.setCommonClassDao(commonClassDao);
 453         PolicyEditorScopes editorScope = new PolicyEditorScopes();
 454         UserInfo userInfo = new UserInfo();
 455         userInfo.setUserName("API");
 456         userInfo.setUserLoginId("API");
 457         editorScope.setScopeName("test");
 458         editorScope.setUserCreatedBy(userInfo);
 459         editorScope.setUserModifiedBy(userInfo);
 460         Mockito.when(commonClassDao.getEntityItem(PolicyEditorScopes.class, "scopeName", "test"))
 461                 .thenReturn(editorScope);
 462         BRMSParamTemplate template = new BRMSParamTemplate();
 463         template.setRuleName("testPolicy");
 464         template.setUserCreatedBy(userInfo);
 465         String rule = "package com.sample;\n" + "import com.sample.DroolsTest.Message;\n" + "declare Params\n"
 466                 + "samPoll : int\n" + "value : String\n" + "end\n" + "///This Rule will be generated by the UI.\n"
 467                 + "rule \"${policyName}.Create parameters structure\"\n" + "salience 1000  \n" + "when\n" + "then\n"
 468                 + "Params params = new Params();\n" + "params.setSamPoll(76);\n" + "params.setValue(\"test\");\n"
 469                 + "insertLogical(params);\n" + "end\n"
 470                 + "rule \"Rule 1: Check parameter structure access from when/then\"\n" + "when\n" + "$param: Params()\n"
 471                 + "Params($param.samPoll > 50)\n" + "then\n" + "System.out.println(\"Firing rule 1\");\n"
 472                 + "System.out.println($param);\n" + "end\n";
 473         template.setRule(rule);
 474         Mockito.when(commonClassDao.getEntityItem(BRMSParamTemplate.class, "ruleName", "testPolicy"))
 475                 .thenReturn(template);
 476     }
 477
 478     @Test
 479     public void testClosedLoopCreateDictionary() throws IOException, SQLException, ServletException {
 480         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 481         // Check VSCLAction.
 482         String json = "{\"dictionaryFields\": {\"vsclaction\": \"testRestAPI\",\"description\": \"testing create\"}}";
 483         dictionaryTestSetup(false, "VSCLAction", json);
 484         // set DBDao
 485         ClosedLoopDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
 486         // send Request to PAP
 487         pap.service(httpServletRequest, httpServletResponse);
 488         // Verify
 489         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 490         //
 491         // Check VNFType
 492         //
 493         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 494         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 495         json = "{\"dictionaryFields\": {\"vnftype\": \"testrestAPI1\",\"description\": \"testing create\"}}";
 496         dictionaryTestSetup(false, "VNFType", json);
 497         // send Request to PAP
 498         pap.service(httpServletRequest, httpServletResponse);
 499         // Verify
 500         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 501         //
 502         // Check PEPOptions
 503         //
 504         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 505         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 506         json = "{\"dictionaryFields\":{\"pepName\":\"testRestAPI\",\"description\":\"testing create\","
 507                 + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
 508                 + "\"number\":\"test\"}]}}";
 509         dictionaryTestSetup(false, "PEPOptions", json);
 510         // send Request to PAP
 511         pap.service(httpServletRequest, httpServletResponse);
 512         // Verify
 513         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 514         //
 515         // Check Varbind
 516         //
 517         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 518         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 519         json = "{\"dictionaryFields\":{\"varbindName\":\"testRestAPI\",\"varbindDescription\":\"testing\","
 520                 + "\"varbindOID\":\"test\"}}";
 521         dictionaryTestSetup(false, "Varbind", json);
 522         // send Request to PAP
 523         pap.service(httpServletRequest, httpServletResponse);
 524         // Verify
 525         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 526         //
 527         // Check Service
 528         //
 529         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 530         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 531         json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPI\",\"description\":\"testing\"}}";
 532         dictionaryTestSetup(false, "Service", json);
 533         // send Request to PAP
 534         pap.service(httpServletRequest, httpServletResponse);
 535         // Verify
 536         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 537         //
 538         // Check Site
 539         //
 540         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 541         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 542         json = "{\"dictionaryFields\":{\"siteName\":\"testRestAPI\",\"description\":\"testing\"}}";
 543         dictionaryTestSetup(false, "Site", json);
 544         // send Request to PAP
 545         pap.service(httpServletRequest, httpServletResponse);
 546         // Verify
 547         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 548     }
 549
 550     @Test
 551     public void testFirewallCreateDictionary() throws IOException, SQLException, ServletException {
 552         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 553         // Check SecurityZone.
 554         String json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"testing\"}}";
 555         dictionaryTestSetup(false, "SecurityZone", json);
 556         // set DBDao
 557         FirewallDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
 558         // send Request to PAP
 559         pap.service(httpServletRequest, httpServletResponse);
 560         // Verify
 561         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 562         //
 563         // Check Action List
 564         //
 565         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 566         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 567         json = "{\"dictionaryFields\":{\"actionName\":\"testRestAPI\",\"description\":\"test\"}}";
 568         dictionaryTestSetup(false, "ActionList", json);
 569         // send Request to PAP
 570         pap.service(httpServletRequest, httpServletResponse);
 571         // Verify
 572         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 573         //
 574         // Check Protocol List.
 575         //
 576         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 577         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 578         json = "{\"dictionaryFields\":{\"protocolName\":\"testRestAPI\",\"description\":\"test\"}}";
 579         dictionaryTestSetup(false, "ProtocolList", json);
 580         // send Request to PAP
 581         pap.service(httpServletRequest, httpServletResponse);
 582         // Verify
 583         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 584         //
 585         // Check Zone.
 586         //
 587         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 588         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 589         json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"test\"}}";
 590         dictionaryTestSetup(false, "Zone", json);
 591         // send Request to PAP
 592         pap.service(httpServletRequest, httpServletResponse);
 593         // Verify
 594         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 595         //
 596         // Check PrefixList.
 597         //
 598         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 599         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 600         json = "{\"dictionaryFields\":{\"prefixListName\":\"testRestAPI\",\"prefixListValue\":\"127.0.0.1\","
 601                 + "\"description\":\"testing\"}}";
 602         dictionaryTestSetup(false, "PrefixList", json);
 603         // send Request to PAP
 604         pap.service(httpServletRequest, httpServletResponse);
 605         // Verify
 606         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 607         //
 608         // Check AddressGroup.
 609         //
 610         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 611         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 612         json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIgroup\",\"description\":\"testing\","
 613                 + "\"attributes\":[{\"option\":\"testRestAPI\"}, {\"option\":\"testRestAPI\"}]}}";
 614         dictionaryTestSetup(false, "AddressGroup", json);
 615         // send Request to PAP
 616         pap.service(httpServletRequest, httpServletResponse);
 617         // Verify
 618         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 619         //
 620         // Check ServiceGroup.
 621         //
 622         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 623         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 624         json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIServiceGroup\","
 625                 + "\"attributes\":[{\"option\":\"testRestAPIservice\"}]}}";
 626         dictionaryTestSetup(false, "ServiceGroup", json);
 627         // send Request to PAP
 628         pap.service(httpServletRequest, httpServletResponse);
 629         // Verify
 630         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 631         //
 632         // Check ServiceList.
 633         //
 634         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 635         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 636         json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPIservice\",\"serviceDescription\":\"test\","
 637                 + "\"servicePorts\":\"8888\",\"transportProtocols\":[{\"option\":\"testRestAPI\"},"
 638                 + "{\"option\":\"testRestAPI1\"}],\"appProtocols\":[{\"option\":\"testRestAPI\"},"
 639                 + "{\"option\":\"testRestAPI1\"}]}}";
 640         dictionaryTestSetup(false, "ServiceList", json);
 641         // send Request to PAP
 642         pap.service(httpServletRequest, httpServletResponse);
 643         // Verify
 644         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 645         //
 646         // Check TermList.
 647         //
 648         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 649         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 650         json = "{\"dictionaryFields\":{\"termName\":\"testRestAPIRule\",\"termDescription\":\"testing\","
 651                 + "\"fromZoneDatas\":[{\"option\":\"testRestAPI\"}],"
 652                 + "\"toZoneDatas\":[{\"option\":\"testRestAPI1\"}],"
 653                 + "\"sourceListDatas\":[{\"option\":\"Group_testportal\"}],"
 654                 + "\"destinationListDatas\":[{\"option\":\"testRestAPI\"}],"
 655                 + "\"sourceServiceDatas\":[{\"option\":\"testRestAPIservice\"},"
 656                 + "{\"option\":\"testRestAPIservice1\"}],"
 657                 + "\"destinationServiceDatas\":[{\"option\":\"testRestAPIservice1\"},"
 658                 + "{\"option\":\"testportalservice2\"}],\"actionListDatas\":[{\"option\":\"testRestAPI\"}]}}";
 659         dictionaryTestSetup(false, "TermList", json);
 660         // send Request to PAP
 661         pap.service(httpServletRequest, httpServletResponse);
 662         // Verify
 663         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 664     }
 665
 666     @Test
 667     public void testCommonCreateDictionary() throws IOException, SQLException, ServletException {
 668         new DictionaryController(commonClassDao);
 669         new ActionPolicyDictionaryController(commonClassDao);
 670         new SafePolicyController(commonClassDao);
 671         new DescriptiveDictionaryController(commonClassDao);
 672         List<Object> object = new ArrayList<>();
 673         object.add(new Category());
 674         when(commonClassDao.getDataById(Category.class, "shortName", "resource")).thenReturn(object);
 675         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 676         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 677         String json =
 678                 "{\"dictionaryFields\": {\"onapName\": \"testMMRestAPI1\",\"description\": \"testing update response "
 679                         + "message\"}}";
 680         dictionaryTestSetup(false, "OnapName", json);
 681         // send Request to PAP
 682         pap.service(httpServletRequest, httpServletResponse);
 683         // Verify
 684         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 685
 686         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 687         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 688         json = "{\"dictionaryFields\": {\"xacmlId\": \"testMMRestAPI1\",\"datatypeBean\": {\"shortName\": "
 689                 + "\"string\"}, \"description\": \"testing update\",\"priority\": \"High\","
 690                 + "\"userDataTypeValues\": [{\"attributeValues\": \"testAttr\"}, {\"attributeValues\": "
 691                 + "\"testAttr2\"}, {\"attributeValues\": \"testAttr3\"}]}}";
 692         dictionaryTestSetup(false, "Attribute", json);
 693         // send Request to PAP
 694         pap.service(httpServletRequest, httpServletResponse);
 695         // Verify
 696         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 697
 698         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 699         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 700         json = "{\"dictionaryFields\":{\"attributeName\":\"TestMMrestAPI1\",\"type\":\"REST\",\"url\":\"testsomeurl"
 701                 + ".com\",\"method\":\"GET\",\"description\":\"test create\",\"body\":\"Testing Create\","
 702                 + "\"headers\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
 703                 + "\"number\":\"test\"}]}}";
 704         dictionaryTestSetup(false, "Action", json);
 705         // send Request to PAP
 706         pap.service(httpServletRequest, httpServletResponse);
 707         // Verify
 708         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 709
 710         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 711         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 712         json = "{\"dictionaryFields\":{\"scopeName\":\"testMMRestAPI1\",\"description\":\"test\","
 713                 + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
 714                 + "\"number\":\"test\"}]}}";
 715         dictionaryTestSetup(false, "DescriptiveScope", json);
 716         // send Request to PAP
 717         pap.service(httpServletRequest, httpServletResponse);
 718         // Verify
 719         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 720
 721         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 722         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 723         json = "{\"dictionaryFields\":{\"riskName\":\"testMMrestAPI1\",\"description\":\"test\"}}";
 724         dictionaryTestSetup(false, "RiskType", json);
 725         // send Request to PAP
 726         pap.service(httpServletRequest, httpServletResponse);
 727         // Verify
 728         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 729
 730         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 731         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 732         json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"message\":\"test\","
 733                 + "\"riskType\":\"testMMrestAPI1\"}}";
 734         dictionaryTestSetup(false, "SafePolicyWarning", json);
 735         // send Request to PAP
 736         pap.service(httpServletRequest, httpServletResponse);
 737         // Verify
 738         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 739     }
 740
 741     @Test
 742     public void testDecisionCreateDictionary() throws IOException, SQLException, ServletException {
 743         new DecisionPolicyDictionaryController(commonClassDao);
 744         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 745         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 746         String json =
 747                 "{\"dictionaryFields\":{\"xacmlId\":\"testMMRestAPI1\",\"datatypeBean\":{\"shortName\":\"string\"},"
 748                         + "\"description\":\"test\",\"priority\":\"High\"}}";
 749         dictionaryTestSetup(false, "Settings", json);
 750         // send Request to PAP
 751         pap.service(httpServletRequest, httpServletResponse);
 752         // Verify
 753         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 754
 755         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 756         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 757         json = "{\"dictionaryFields\":{\"bbid\":\"BB1\",\"workstep\":\"1\",\"treatments\":\"Manual Handling,Abort,"
 758                 + "Retry\"}}";
 759         dictionaryTestSetup(false, "RainyDayTreatments", json);
 760         // send Request to PAP
 761         pap.service(httpServletRequest, httpServletResponse);
 762         // Verify
 763         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 764     }
 765
 766     @Test
 767     public void testMSCreateDictionary() throws IOException, SQLException, ServletException {
 768         new MicroServiceDictionaryController(commonClassDao);
 769         new PolicyScopeDictionaryController(commonClassDao);
 770         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 771         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 772         String json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"descriptionValue\":\"test\"}}";
 773         dictionaryTestSetup(false, "MicroServiceLocation", json);
 774         // send Request to PAP
 775         pap.service(httpServletRequest, httpServletResponse);
 776         // Verify
 777         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 778
 779         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 780         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 781         json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"descriptionValue\":\"test\"}}";
 782         dictionaryTestSetup(false, "MicroServiceConfigName", json);
 783         // send Request to PAP
 784         pap.service(httpServletRequest, httpServletResponse);
 785         // Verify
 786         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 787
 788         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 789         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 790         json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"description\":\"test\"}}";
 791         dictionaryTestSetup(false, "DCAEUUID", json);
 792         // send Request to PAP
 793         pap.service(httpServletRequest, httpServletResponse);
 794         // Verify
 795         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 796
 797         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 798         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 799         json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
 800         dictionaryTestSetup(false, "PolicyScopeService", json);
 801         // send Request to PAP
 802         pap.service(httpServletRequest, httpServletResponse);
 803         // Verify
 804         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 805
 806         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 807         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 808         json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
 809         dictionaryTestSetup(false, "PolicyScopeResource", json);
 810         // send Request to PAP
 811         pap.service(httpServletRequest, httpServletResponse);
 812         // Verify
 813         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 814
 815         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 816         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 817         json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
 818         dictionaryTestSetup(false, "PolicyScopeType", json);
 819         // send Request to PAP
 820         pap.service(httpServletRequest, httpServletResponse);
 821         // Verify
 822         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 823
 824         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 825         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 826         json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
 827         dictionaryTestSetup(false, "PolicyScopeClosedLoop", json);
 828         // send Request to PAP
 829         pap.service(httpServletRequest, httpServletResponse);
 830         // Verify
 831         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 832
 833         httpServletRequest = Mockito.mock(HttpServletRequest.class);
 834         httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
 835         json = "{\"dictionaryFields\":{\"groupName\":\"testMMrestAPI1\",\"description\":\"testing\"},"
 836                 + "\"groupPolicyScopeListData1\":{\"resource\":\"ANY\",\"type\":\"ANY\",\"service\":\"ANY\","
 837                 + "\"closedloop\":\"ANY\"}}";
 838         dictionaryTestSetup(false, "GroupPolicyScopeList", json);
 839         // send Request to PAP
 840         pap.service(httpServletRequest, httpServletResponse);
 841         // Verify
 842         Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
 843     }
 844
 845     private void dictionaryTestSetup(Boolean updateFlag, String dictionaryType, String json)
 846             throws IOException, SQLException {
 847         Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 848         Mockito.when(httpServletRequest.getHeader("ClientScope")).thenReturn("dictionaryItem");
 849         Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
 850         Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 851         if (updateFlag) {
 852             Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("update");
 853         } else {
 854             Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
 855         }
 856         Mockito.when(httpServletRequest.getParameter("dictionaryType")).thenReturn(dictionaryType);
 857         MockServletInputStream mockInput = new MockServletInputStream(json.getBytes());
 858         Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
 859         Mockito.when(httpServletRequest.getReader()).thenReturn(new BufferedReader(new InputStreamReader(mockInput)));
 860     }
 861
 862     public void setDBDao() throws SQLException {
 863         BasicDataSource dataSource = new BasicDataSource();
 864         dataSource.setDriverClassName("org.h2.Driver");
 865         // In-memory DB for testing
 866         dataSource.setUrl("jdbc:h2:mem:test");
 867         dataSource.setUsername("sa");
 868         dataSource.setPassword("");
 869         LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
 870         sessionBuilder.scanPackages("org.onap.*", "com.*");
 871
 872         Properties properties = new Properties();
 873         properties.put("hibernate.show_sql", "false");
 874         properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
 875         properties.put("hibernate.hbm2ddl.auto", "drop");
 876         properties.put("hibernate.hbm2ddl.auto", "create");
 877
 878         sessionBuilder.addProperties(properties);
 879         sessionFactory = sessionBuilder.buildSessionFactory();
 880
 881         // Set up dao with SessionFactory
 882         CommonClassDaoImpl.setSessionfactory(sessionFactory);
 883         PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
 884     }
 885
 886     @Test
 887     public void getDictionary() throws ServletException, IOException {
 888         String[] dictionarys = new String[] {"Attribute", "OnapName", "Action", "BRMSParamTemplate", "VSCLAction",
 889                 "VNFType", "PEPOptions", "Varbind", "Service", "Site", "Settings", "RainyDayTreatments",
 890                 "DescriptiveScope", "ActionList", "ProtocolList", "Zone", "SecurityZone", "PrefixList", "AddressGroup",
 891                 "ServiceGroup", "ServiceList", "TermList", "MicroServiceLocation", "MicroServiceConfigName", "DCAEUUID",
 892                 "MicroServiceModels", "PolicyScopeService", "PolicyScopeResource", "PolicyScopeType",
 893                 "PolicyScopeClosedLoop", "GroupPolicyScopeList", "RiskType", "SafePolicyWarning",
 894                 "MicroServiceDictionary"};
 895         for (String dictionary : dictionarys) {
 896             httpServletRequest = Mockito.mock(HttpServletRequest.class);
 897             httpServletResponse = new MockHttpServletResponse();
 898             Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
 899             Mockito.when(httpServletRequest.getMethod()).thenReturn("GET");
 900             Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
 901             Mockito.when(httpServletRequest.getParameter("dictionaryType")).thenReturn(dictionary);
 902             pap.service(httpServletRequest, httpServletResponse);
 903             assertTrue(HttpServletResponse.SC_OK == httpServletResponse.getStatus());
 904         }
 905     }
 906
 907     @Test
 908     public void testDummy() throws ServletException, IOException {
 909
 910         Mockito.when(httpServletRequest.getMethod()).thenReturn("POST");
 911         mockOutput = Mockito.mock(ServletOutputStream.class);
 912
 913         try {
 914             Mockito.when(httpServletResponse.getOutputStream()).thenReturn(mockOutput);
 915         } catch (IOException e) {
 916             fail(e.getMessage());
 917         }
 918
 919         try {
 920             pap.service(httpServletRequest, httpServletResponse);
 921             assertTrue(true);
 922         } catch (Exception e) {
 923             fail(e.getMessage());
 924         }
 925     }
 926
 927     @AfterClass
 928     public static void destroy() {
 929         if (sessionFactory != null) {
 930             sessionFactory.close();
 931         }
 932         pap.destroy();
 933     }
 934 }