2 * ============LICENSE_START=======================================================
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
22 package org.onap.policy.pap.test;
24 import static org.junit.Assert.assertTrue;
25 import static org.junit.Assert.fail;
26 import static org.mockito.Mockito.when;
27 import com.mockrunner.mock.web.MockServletInputStream;
28 import java.io.BufferedReader;
29 import java.io.IOException;
30 import java.io.InputStreamReader;
31 import java.sql.SQLException;
32 import java.util.ArrayList;
33 import java.util.Arrays;
34 import java.util.Collections;
35 import java.util.HashMap;
36 import java.util.List;
38 import java.util.Properties;
39 import javax.servlet.ServletConfig;
40 import javax.servlet.ServletException;
41 import javax.servlet.ServletOutputStream;
42 import javax.servlet.http.HttpServletRequest;
43 import javax.servlet.http.HttpServletResponse;
44 import org.apache.commons.logging.Log;
45 import org.apache.commons.logging.LogFactory;
46 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
47 import org.hibernate.SessionFactory;
48 import org.junit.AfterClass;
49 import org.junit.Before;
50 import org.junit.BeforeClass;
51 import org.junit.Test;
52 import org.mockito.Mockito;
53 import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
54 import org.onap.policy.pap.xacml.rest.components.FirewallConfigPolicy;
55 import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTest;
56 import org.onap.policy.pap.xacml.rest.controller.ActionPolicyDictionaryController;
57 import org.onap.policy.pap.xacml.rest.controller.ClosedLoopDictionaryController;
58 import org.onap.policy.pap.xacml.rest.controller.DecisionPolicyDictionaryController;
59 import org.onap.policy.pap.xacml.rest.controller.DescriptiveDictionaryController;
60 import org.onap.policy.pap.xacml.rest.controller.DictionaryController;
61 import org.onap.policy.pap.xacml.rest.controller.FirewallDictionaryController;
62 import org.onap.policy.pap.xacml.rest.controller.MicroServiceDictionaryController;
63 import org.onap.policy.pap.xacml.rest.controller.PolicyScopeDictionaryController;
64 import org.onap.policy.pap.xacml.rest.controller.SafePolicyController;
65 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
66 import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
67 import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
68 import org.onap.policy.rest.dao.CommonClassDao;
69 import org.onap.policy.rest.jpa.ActionPolicyDict;
70 import org.onap.policy.rest.jpa.BRMSParamTemplate;
71 import org.onap.policy.rest.jpa.Category;
72 import org.onap.policy.rest.jpa.FunctionDefinition;
73 import org.onap.policy.rest.jpa.PolicyEditorScopes;
74 import org.onap.policy.rest.jpa.UserInfo;
75 import org.onap.policy.utils.PolicyUtils;
76 import org.onap.policy.xacml.std.pap.StdPAPPolicy;
77 import org.onap.policy.xacml.std.pap.StdPAPPolicyParams;
78 import org.springframework.mock.web.MockHttpServletResponse;
79 import org.springframework.mock.web.MockServletConfig;
80 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
83 public class XACMLPAPTest {
84 private static final Log logger = LogFactory.getLog(XACMLPAPTest.class);
86 private static final String ENVIRONMENT_HEADER = "Environment";
87 private static List<String> headers = new ArrayList<>();
88 private HttpServletRequest httpServletRequest;
89 private HttpServletResponse httpServletResponse;
90 private ServletOutputStream mockOutput;
91 private static ServletConfig servletConfig;
92 private static XACMLPapServlet pap;
93 private static SessionFactory sessionFactory;
94 private static CommonClassDao commonClassDao;
96 private static final String DEFAULT_DB_DRIVER = "org.h2.Driver";
97 private static final String DEFAULT_DB_USER = "sa";
98 private static final String DEFAULT_DB_PWD = "";
101 public static void beforeClassSetup() throws ServletException {
102 sessionFactory = PolicyDBDaoTest.setupH2DbDaoImpl("xacmlpaptest");
103 new FirewallConfigPolicy(new CommonClassDaoImpl());
104 new DictionaryUtils(new CommonClassDaoImpl());
108 public static void setUp() throws ServletException {
109 servletConfig = Mockito.mock(MockServletConfig.class);
110 System.setProperty("com.sun.management.jmxremote.port", "9993");
111 Mockito.when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
112 Mockito.when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME"))
113 .thenReturn("src/test/resources/xacml.pap.properties");
114 pap = new XACMLPapServlet();
115 pap.init(servletConfig);
116 commonClassDao = Mockito.mock(CommonClassDao.class);
117 new DictionaryUtils(commonClassDao);
118 DictionaryUtils.setDictionaryUtils(new DictionaryUtils());
119 UserInfo user = new UserInfo();
120 user.setUserLoginId("API");
121 user.setUserName("API");
122 Mockito.when(commonClassDao.getEntityItem(UserInfo.class, "userLoginId", "API")).thenReturn(user);
123 Mockito.mock(DictionaryUtils.class);
127 public void testInit() {
128 httpServletRequest = Mockito.mock(HttpServletRequest.class);
129 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
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());
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,"
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("")
163 MockServletInputStream mockInput =
164 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
165 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
167 pap.service(httpServletRequest, httpServletResponse);
168 Mockito.verify(httpServletResponse).addHeader("operation", "create");
172 public void testBRMSCreatePolicy() throws IOException, ServletException, SQLException {
173 httpServletRequest = Mockito.mock(HttpServletRequest.class);
174 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
175 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
176 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
177 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
178 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
179 Map<String, String> matchingAttributes = new HashMap<>();
180 Map<String, String> ruleAttributes = new HashMap<>();
181 ruleAttributes.put("templateName", "testPolicy");
182 ruleAttributes.put("samPoll", "5");
183 ruleAttributes.put("value", "test");
184 // Creating BRMS Param Policies from the Admin Console
185 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Param")
186 .policyName("test").description("testing").configName("BRMS_PARAM_RULE").editPolicy(false)
187 .domain("test").dynamicFieldConfigAttributes(matchingAttributes).highestVersion(0).onapName("DROOLS")
188 .configBodyData(null).drlRuleAndUIParams(ruleAttributes).riskLevel("5").riskType("default")
189 .guard("false").ttlDate("").brmsController(null).brmsDependency(null).build());
190 MockServletInputStream mockInput =
191 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
192 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
195 pap.service(httpServletRequest, httpServletResponse);
196 Mockito.verify(httpServletResponse).addHeader("operation", "create");
200 public void testBRMSRawCreatePolicy() throws IOException, ServletException, SQLException {
201 httpServletRequest = Mockito.mock(HttpServletRequest.class);
202 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
203 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
204 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
205 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
206 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
207 Map<String, String> ruleAttributes = new HashMap<>();
208 ruleAttributes.put("value", "test");
209 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Raw")
210 .policyName("test").description("testig description").configName("BRMS_RAW_RULE").editPolicy(false)
211 .domain("test").dynamicFieldConfigAttributes(ruleAttributes).highestVersion(0).onapName("DROOLS")
212 .configBodyData("test").riskLevel("4").riskType("default").guard("false").build());
213 MockServletInputStream mockInput =
214 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
215 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
218 pap.service(httpServletRequest, httpServletResponse);
219 Mockito.verify(httpServletResponse).addHeader("operation", "create");
223 public void testClosedLoopPMCreatePolicy() throws IOException, ServletException, SQLException {
224 httpServletRequest = Mockito.mock(HttpServletRequest.class);
225 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
226 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
227 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
228 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
229 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
230 String json = "{\"test\":\"java\"}";
231 // Creating CloseLoop_Fault and Performance Metric Policies
232 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("ClosedLoop_PM")
233 .policyName("test").description("testing").onapName("onap").jsonBody(json).draft(false)
234 .oldPolicyFileName(null).serviceType("Registration Failure(Trinity)").editPolicy(false).domain("test")
235 .highestVersion(0).riskLevel(null).riskType("default").guard("true").ttlDate("").build());
236 MockServletInputStream mockInput =
237 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
238 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
241 pap.service(httpServletRequest, httpServletResponse);
242 Mockito.verify(httpServletResponse).addHeader("operation", "create");
246 public void testDecisonAAFPolicy() throws IOException, ServletException, SQLException {
247 httpServletRequest = Mockito.mock(HttpServletRequest.class);
248 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
249 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
250 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
251 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
252 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
253 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
254 StdPAPPolicyParams.builder().policyName("test").description("test rule").onapName("ONAP")
255 .providerComboBox("AAF").editPolicy(false).domain("test").highestVersion(0).build());
256 MockServletInputStream mockInput =
257 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
258 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
260 pap.service(httpServletRequest, httpServletResponse);
261 Mockito.verify(httpServletResponse).addHeader("operation", "create");
265 public void testDecisonGuardPolicy() throws IOException, ServletException, SQLException {
266 httpServletRequest = Mockito.mock(HttpServletRequest.class);
267 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
268 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
269 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
270 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
271 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
272 Map<String, String> matchingAttributes = new HashMap<>();
273 matchingAttributes.put("actor", "test");
274 matchingAttributes.put("recipe", "restart");
275 matchingAttributes.put("targets", "test,test1");
276 matchingAttributes.put("clname", "");
277 matchingAttributes.put("limit", "1");
278 matchingAttributes.put("timeWindow", "15");
279 matchingAttributes.put("timeUnits", "minute");
280 matchingAttributes.put("guardActiveStart", "05:00");
281 matchingAttributes.put("guardActiveEnd", "10:00");
282 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
283 StdPAPPolicyParams.builder().policyName("testGuard").description("test rule").onapName("PDPD")
284 .providerComboBox("GUARD_YAML").dynamicFieldConfigAttributes(matchingAttributes)
285 .editPolicy(false).domain("test").highestVersion(0).build());
286 MockServletInputStream mockInput =
287 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
288 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
290 pap.service(httpServletRequest, httpServletResponse);
291 Mockito.verify(httpServletResponse).addHeader("operation", "create");
295 public void testDecisonGuardMinMaxPolicy() throws IOException, ServletException, SQLException {
296 httpServletRequest = Mockito.mock(HttpServletRequest.class);
297 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
298 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
299 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
300 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
301 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
302 Map<String, String> matchingAttributes = new HashMap<>();
303 matchingAttributes.put("actor", "test");
304 matchingAttributes.put("recipe", "scaleOut");
305 matchingAttributes.put("targets", "test,test1");
306 matchingAttributes.put("clname", "test");
307 matchingAttributes.put("min", "1");
308 matchingAttributes.put("max", "5");
309 matchingAttributes.put("guardActiveStart", "05:00");
310 matchingAttributes.put("guardActiveEnd", "10:00");
311 StdPAPPolicy newPAPPolicy =
313 new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("testGuardMinMax").description("test rule")
314 .onapName("PDPD").providerComboBox("GUARD_MIN_MAX")
315 .dynamicFieldConfigAttributes(matchingAttributes).editPolicy(false).domain("test")
316 .highestVersion(0).build());
317 MockServletInputStream mockInput =
318 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
319 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
321 pap.service(httpServletRequest, httpServletResponse);
322 Mockito.verify(httpServletResponse).addHeader("operation", "create");
327 public void testDecisonBLGuardPolicy() throws IOException, ServletException, SQLException {
328 httpServletRequest = Mockito.mock(HttpServletRequest.class);
329 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
330 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
331 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
332 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
333 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
334 Map<String, String> matchingAttributes = new HashMap<>();
335 matchingAttributes.put("actor", "test");
336 matchingAttributes.put("recipe", "restart");
337 matchingAttributes.put("clname", "test");
338 matchingAttributes.put("guardActiveStart", "05:00");
339 matchingAttributes.put("guardActiveEnd", "10:00");
340 matchingAttributes.put("blackList", "bl1,bl2");
341 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
342 StdPAPPolicyParams.builder().policyName("testblGuard").description("test rule").onapName("PDPD")
343 .providerComboBox("GUARD_BL_YAML").dynamicFieldConfigAttributes(matchingAttributes)
344 .editPolicy(false).domain("test").highestVersion(0).build());
345 MockServletInputStream mockInput =
346 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
347 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
349 pap.service(httpServletRequest, httpServletResponse);
350 Mockito.verify(httpServletResponse).addHeader("operation", "create");
354 public void testConfigPolicy() throws IOException, ServletException, SQLException {
355 httpServletRequest = Mockito.mock(HttpServletRequest.class);
356 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
357 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
358 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
359 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
360 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
361 Map<String, String> configAttributes = new HashMap<>();
362 configAttributes.put("value", "test");
363 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
364 StdPAPPolicyParams.builder().configPolicyType("Base").policyName("test").description("test rule")
365 .onapName("TEST").configName("config").dynamicFieldConfigAttributes(configAttributes)
366 .configType("OTHER").configBodyData("test body").editPolicy(false).domain("test")
367 .highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate(null).build());
368 MockServletInputStream mockInput =
369 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
370 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
372 pap.service(httpServletRequest, httpServletResponse);
373 Mockito.verify(httpServletResponse).addHeader("operation", "create");
377 public void testActionPolicy() throws IOException, ServletException, SQLException {
379 httpServletRequest = Mockito.mock(HttpServletRequest.class);
380 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
381 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
382 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("API");
383 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
384 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Action");
386 CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
387 PolicyCreation.setCommonClassDao(commonClassDao);
388 ActionPolicyDict actionDict = new ActionPolicyDict();
389 actionDict.setBody("{\"test\":\"test\"}");
390 actionDict.setHeader("test122=test12:test22=test34");
391 actionDict.setType("REST");
392 actionDict.setMethod("GET");
393 actionDict.setUrl("testsomeurl.com");
394 Mockito.when(commonClassDao.getEntityItem(ActionPolicyDict.class, "attributeName", "test"))
395 .thenReturn(actionDict);
396 FunctionDefinition funcDefn = new FunctionDefinition();
397 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:and");
398 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "and")).thenReturn(funcDefn);
399 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-equal");
400 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-equal"))
401 .thenReturn(funcDefn);
402 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:3.0:function:string-contains");
403 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "string-contains"))
404 .thenReturn(funcDefn);
405 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-greater-than");
406 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-greater-than"))
407 .thenReturn(funcDefn);
408 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:or");
409 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "or")).thenReturn(funcDefn);
411 Map<String, String> componentAttributes = new HashMap<>();
412 componentAttributes.put("java", "test");
413 StdPAPPolicy newPapPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("test").description("test")
414 .dynamicFieldConfigAttributes(componentAttributes)
415 .dynamicRuleAlgorithmLabels(Arrays.asList("A1", "A2", "A3", "A4", "A5", "A6", "A7"))
416 .dynamicRuleAlgorithmCombo(Arrays.asList("integer-equal", "string-contains", "integer-equal", "and",
417 "integer-greater-than", "or", "and"))
418 .dynamicRuleAlgorithmField1(Arrays.asList("cobal", "cap", "cobal", "A2", "Config", "A4", "A1"))
419 .dynamicRuleAlgorithmField2(Arrays.asList("90", "ca", "90", "A3", "45", "A5", "A6"))
420 .actionPerformer("PDP").actionAttribute("test").editPolicy(false).domain("com").highestVersion(0)
422 newPapPolicy.setActionBody("{\"test\":\"test\"}");
424 MockServletInputStream mockInput =
425 new MockServletInputStream(PolicyUtils.objectToJsonString(newPapPolicy).getBytes());
426 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
428 pap.service(httpServletRequest, httpServletResponse);
429 Mockito.verify(httpServletResponse).addHeader("operation", "create");
433 private void setPolicyCreation() {
434 CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
435 PolicyCreation.setCommonClassDao(commonClassDao);
436 PolicyEditorScopes editorScope = new PolicyEditorScopes();
437 UserInfo userInfo = new UserInfo();
438 userInfo.setUserName("API");
439 userInfo.setUserLoginId("API");
440 editorScope.setScopeName("test");
441 editorScope.setUserCreatedBy(userInfo);
442 editorScope.setUserModifiedBy(userInfo);
443 Mockito.when(commonClassDao.getEntityItem(PolicyEditorScopes.class, "scopeName", "test"))
444 .thenReturn(editorScope);
445 BRMSParamTemplate template = new BRMSParamTemplate();
446 template.setRuleName("testPolicy");
447 template.setUserCreatedBy(userInfo);
448 String rule = "package com.sample;\n" + "import com.sample.DroolsTest.Message;\n" + "declare Params\n"
449 + "samPoll : int\n" + "value : String\n" + "end\n" + "///This Rule will be generated by the UI.\n"
450 + "rule \"${policyName}.Create parameters structure\"\n" + "salience 1000 \n" + "when\n" + "then\n"
451 + "Params params = new Params();\n" + "params.setSamPoll(76);\n" + "params.setValue(\"test\");\n"
452 + "insertLogical(params);\n" + "end\n"
453 + "rule \"Rule 1: Check parameter structure access from when/then\"\n" + "when\n" + "$param: Params()\n"
454 + "Params($param.samPoll > 50)\n" + "then\n" + "System.out.println(\"Firing rule 1\");\n"
455 + "System.out.println($param);\n" + "end\n";
456 template.setRule(rule);
457 Mockito.when(commonClassDao.getEntityItem(BRMSParamTemplate.class, "ruleName", "testPolicy"))
458 .thenReturn(template);
462 public void testClosedLoopCreateDictionary() throws IOException, SQLException, ServletException {
463 httpServletRequest = Mockito.mock(HttpServletRequest.class);
465 String json = "{\"dictionaryFields\": {\"vsclaction\": \"testRestAPI\",\"description\": \"testing create\"}}";
466 dictionaryTestSetup(false, "VSCLAction", json);
468 ClosedLoopDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
469 // send Request to PAP
470 pap.service(httpServletRequest, httpServletResponse);
472 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
476 httpServletRequest = Mockito.mock(HttpServletRequest.class);
477 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
478 json = "{\"dictionaryFields\": {\"vnftype\": \"testrestAPI1\",\"description\": \"testing create\"}}";
479 dictionaryTestSetup(false, "VNFType", json);
480 // send Request to PAP
481 pap.service(httpServletRequest, httpServletResponse);
483 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
487 httpServletRequest = Mockito.mock(HttpServletRequest.class);
488 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
489 json = "{\"dictionaryFields\":{\"pepName\":\"testRestAPI\",\"description\":\"testing create\","
490 + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
491 + "\"number\":\"test\"}]}}";
492 dictionaryTestSetup(false, "PEPOptions", json);
493 // send Request to PAP
494 pap.service(httpServletRequest, httpServletResponse);
496 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
500 httpServletRequest = Mockito.mock(HttpServletRequest.class);
501 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
502 json = "{\"dictionaryFields\":{\"varbindName\":\"testRestAPI\",\"varbindDescription\":\"testing\","
503 + "\"varbindOID\":\"test\"}}";
504 dictionaryTestSetup(false, "Varbind", json);
505 // send Request to PAP
506 pap.service(httpServletRequest, httpServletResponse);
508 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
512 httpServletRequest = Mockito.mock(HttpServletRequest.class);
513 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
514 json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPI\",\"description\":\"testing\"}}";
515 dictionaryTestSetup(false, "Service", json);
516 // send Request to PAP
517 pap.service(httpServletRequest, httpServletResponse);
519 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
523 httpServletRequest = Mockito.mock(HttpServletRequest.class);
524 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
525 json = "{\"dictionaryFields\":{\"siteName\":\"testRestAPI\",\"description\":\"testing\"}}";
526 dictionaryTestSetup(false, "Site", json);
527 // send Request to PAP
528 pap.service(httpServletRequest, httpServletResponse);
530 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
534 public void testFirewallCreateDictionary() throws IOException, SQLException, ServletException {
535 httpServletRequest = Mockito.mock(HttpServletRequest.class);
536 // Check SecurityZone.
537 String json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"testing\"}}";
538 dictionaryTestSetup(false, "SecurityZone", json);
540 FirewallDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
541 // send Request to PAP
542 pap.service(httpServletRequest, httpServletResponse);
544 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
548 httpServletRequest = Mockito.mock(HttpServletRequest.class);
549 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
550 json = "{\"dictionaryFields\":{\"actionName\":\"testRestAPI\",\"description\":\"test\"}}";
551 dictionaryTestSetup(false, "ActionList", json);
552 // send Request to PAP
553 pap.service(httpServletRequest, httpServletResponse);
555 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
557 // Check Protocol List.
559 httpServletRequest = Mockito.mock(HttpServletRequest.class);
560 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
561 json = "{\"dictionaryFields\":{\"protocolName\":\"testRestAPI\",\"description\":\"test\"}}";
562 dictionaryTestSetup(false, "ProtocolList", json);
563 // send Request to PAP
564 pap.service(httpServletRequest, httpServletResponse);
566 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
570 httpServletRequest = Mockito.mock(HttpServletRequest.class);
571 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
572 json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"test\"}}";
573 dictionaryTestSetup(false, "Zone", json);
574 // send Request to PAP
575 pap.service(httpServletRequest, httpServletResponse);
577 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
581 httpServletRequest = Mockito.mock(HttpServletRequest.class);
582 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
583 json = "{\"dictionaryFields\":{\"prefixListName\":\"testRestAPI\",\"prefixListValue\":\"127.0.0.1\","
584 + "\"description\":\"testing\"}}";
585 dictionaryTestSetup(false, "PrefixList", json);
586 // send Request to PAP
587 pap.service(httpServletRequest, httpServletResponse);
589 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
591 // Check AddressGroup.
593 httpServletRequest = Mockito.mock(HttpServletRequest.class);
594 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
595 json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIgroup\",\"description\":\"testing\","
596 + "\"attributes\":[{\"option\":\"testRestAPI\"}, {\"option\":\"testRestAPI\"}]}}";
597 dictionaryTestSetup(false, "AddressGroup", json);
598 // send Request to PAP
599 pap.service(httpServletRequest, httpServletResponse);
601 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
603 // Check ServiceGroup.
605 httpServletRequest = Mockito.mock(HttpServletRequest.class);
606 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
607 json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIServiceGroup\","
608 + "\"attributes\":[{\"option\":\"testRestAPIservice\"}]}}";
609 dictionaryTestSetup(false, "ServiceGroup", json);
610 // send Request to PAP
611 pap.service(httpServletRequest, httpServletResponse);
613 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
615 // Check ServiceList.
617 httpServletRequest = Mockito.mock(HttpServletRequest.class);
618 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
619 json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPIservice\",\"serviceDescription\":\"test\","
620 + "\"servicePorts\":\"8888\",\"transportProtocols\":[{\"option\":\"testRestAPI\"},"
621 + "{\"option\":\"testRestAPI1\"}],\"appProtocols\":[{\"option\":\"testRestAPI\"},"
622 + "{\"option\":\"testRestAPI1\"}]}}";
623 dictionaryTestSetup(false, "ServiceList", json);
624 // send Request to PAP
625 pap.service(httpServletRequest, httpServletResponse);
627 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
631 httpServletRequest = Mockito.mock(HttpServletRequest.class);
632 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
633 json = "{\"dictionaryFields\":{\"termName\":\"testRestAPIRule\",\"termDescription\":\"testing\","
634 + "\"fromZoneDatas\":[{\"option\":\"testRestAPI\"}],"
635 + "\"toZoneDatas\":[{\"option\":\"testRestAPI1\"}],"
636 + "\"sourceListDatas\":[{\"option\":\"Group_testportal\"}],"
637 + "\"destinationListDatas\":[{\"option\":\"testRestAPI\"}],"
638 + "\"sourceServiceDatas\":[{\"option\":\"testRestAPIservice\"},"
639 + "{\"option\":\"testRestAPIservice1\"}],"
640 + "\"destinationServiceDatas\":[{\"option\":\"testRestAPIservice1\"},"
641 + "{\"option\":\"testportalservice2\"}],\"actionListDatas\":[{\"option\":\"testRestAPI\"}]}}";
642 dictionaryTestSetup(false, "TermList", json);
643 // send Request to PAP
644 pap.service(httpServletRequest, httpServletResponse);
646 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
650 public void testCommonCreateDictionary() throws IOException, SQLException, ServletException {
651 new DictionaryController(commonClassDao);
652 new ActionPolicyDictionaryController(commonClassDao);
653 new SafePolicyController(commonClassDao);
654 new DescriptiveDictionaryController(commonClassDao);
655 List<Object> object = new ArrayList<>();
656 object.add(new Category());
657 when(commonClassDao.getDataById(Category.class, "shortName", "resource")).thenReturn(object);
658 httpServletRequest = Mockito.mock(HttpServletRequest.class);
659 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
661 "{\"dictionaryFields\": {\"onapName\": \"testMMRestAPI1\",\"description\": \"testing update response "
663 dictionaryTestSetup(false, "OnapName", json);
664 // send Request to PAP
665 pap.service(httpServletRequest, httpServletResponse);
667 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
669 httpServletRequest = Mockito.mock(HttpServletRequest.class);
670 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
671 json = "{\"dictionaryFields\": {\"xacmlId\": \"testMMRestAPI1\",\"datatypeBean\": {\"shortName\": "
672 + "\"string\"}, \"description\": \"testing update\",\"priority\": \"High\","
673 + "\"userDataTypeValues\": [{\"attributeValues\": \"testAttr\"}, {\"attributeValues\": "
674 + "\"testAttr2\"}, {\"attributeValues\": \"testAttr3\"}]}}";
675 dictionaryTestSetup(false, "Attribute", json);
676 // send Request to PAP
677 pap.service(httpServletRequest, httpServletResponse);
679 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
682 httpServletRequest = Mockito.mock(HttpServletRequest.class);
683 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
684 json = "{\"dictionaryFields\":{\"attributeName\":\"TestMMrestAPI1\",\"type\":\"REST\",\"url\":\"testsomeurl"
685 + ".com\",\"method\":\"GET\",\"description\":\"test create\",\"body\":\"Testing Create\","
686 + "\"headers\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
687 + "\"number\":\"test\"}]}}";
688 dictionaryTestSetup(false, "Action", json);
689 // send Request to PAP
690 pap.service(httpServletRequest, httpServletResponse);
692 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
694 httpServletRequest = Mockito.mock(HttpServletRequest.class);
695 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
696 json = "{\"dictionaryFields\":{\"scopeName\":\"testMMRestAPI1\",\"description\":\"test\","
697 + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
698 + "\"number\":\"test\"}]}}";
699 dictionaryTestSetup(false, "DescriptiveScope", json);
700 // send Request to PAP
701 pap.service(httpServletRequest, httpServletResponse);
703 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
705 httpServletRequest = Mockito.mock(HttpServletRequest.class);
706 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
707 json = "{\"dictionaryFields\":{\"riskName\":\"testMMrestAPI1\",\"description\":\"test\"}}";
708 dictionaryTestSetup(false, "RiskType", json);
709 // send Request to PAP
710 pap.service(httpServletRequest, httpServletResponse);
712 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
714 httpServletRequest = Mockito.mock(HttpServletRequest.class);
715 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
716 json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"message\":\"test\","
717 + "\"riskType\":\"testMMrestAPI1\"}}";
718 dictionaryTestSetup(false, "SafePolicyWarning", json);
719 // send Request to PAP
720 pap.service(httpServletRequest, httpServletResponse);
722 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
726 public void testDecisionCreateDictionary() throws IOException, SQLException, ServletException {
727 new DecisionPolicyDictionaryController(commonClassDao);
728 httpServletRequest = Mockito.mock(HttpServletRequest.class);
729 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
731 "{\"dictionaryFields\":{\"xacmlId\":\"testMMRestAPI1\",\"datatypeBean\":{\"shortName\":\"string\"},"
732 + "\"description\":\"test\",\"priority\":\"High\"}}";
733 dictionaryTestSetup(false, "Settings", json);
734 // send Request to PAP
735 pap.service(httpServletRequest, httpServletResponse);
737 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
739 httpServletRequest = Mockito.mock(HttpServletRequest.class);
740 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
741 json = "{\"dictionaryFields\":{\"bbid\":\"BB1\",\"workstep\":\"1\",\"treatments\":\"Manual Handling,Abort,"
743 dictionaryTestSetup(false, "RainyDayTreatments", json);
744 // send Request to PAP
745 pap.service(httpServletRequest, httpServletResponse);
747 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
751 public void testMSCreateDictionary() throws IOException, SQLException, ServletException {
752 new MicroServiceDictionaryController(commonClassDao);
753 new PolicyScopeDictionaryController(commonClassDao);
754 httpServletRequest = Mockito.mock(HttpServletRequest.class);
755 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
756 String json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"descriptionValue\":\"test\"}}";
757 dictionaryTestSetup(false, "MicroServiceLocation", json);
758 // send Request to PAP
759 pap.service(httpServletRequest, httpServletResponse);
761 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
763 httpServletRequest = Mockito.mock(HttpServletRequest.class);
764 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
765 json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"descriptionValue\":\"test\"}}";
766 dictionaryTestSetup(false, "MicroServiceConfigName", json);
767 // send Request to PAP
768 pap.service(httpServletRequest, httpServletResponse);
770 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
772 httpServletRequest = Mockito.mock(HttpServletRequest.class);
773 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
774 json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"description\":\"test\"}}";
775 dictionaryTestSetup(false, "DCAEUUID", json);
776 // send Request to PAP
777 pap.service(httpServletRequest, httpServletResponse);
779 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
781 httpServletRequest = Mockito.mock(HttpServletRequest.class);
782 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
783 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
784 dictionaryTestSetup(false, "PolicyScopeService", json);
785 // send Request to PAP
786 pap.service(httpServletRequest, httpServletResponse);
788 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
790 httpServletRequest = Mockito.mock(HttpServletRequest.class);
791 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
792 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
793 dictionaryTestSetup(false, "PolicyScopeResource", json);
794 // send Request to PAP
795 pap.service(httpServletRequest, httpServletResponse);
797 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
799 httpServletRequest = Mockito.mock(HttpServletRequest.class);
800 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
801 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
802 dictionaryTestSetup(false, "PolicyScopeType", json);
803 // send Request to PAP
804 pap.service(httpServletRequest, httpServletResponse);
806 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
808 httpServletRequest = Mockito.mock(HttpServletRequest.class);
809 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
810 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
811 dictionaryTestSetup(false, "PolicyScopeClosedLoop", json);
812 // send Request to PAP
813 pap.service(httpServletRequest, httpServletResponse);
815 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
817 httpServletRequest = Mockito.mock(HttpServletRequest.class);
818 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
819 json = "{\"dictionaryFields\":{\"groupName\":\"testMMrestAPI1\",\"description\":\"testing\"},"
820 + "\"groupPolicyScopeListData1\":{\"resource\":\"ANY\",\"type\":\"ANY\",\"service\":\"ANY\","
821 + "\"closedloop\":\"ANY\"}}";
822 dictionaryTestSetup(false, "GroupPolicyScopeList", json);
823 // send Request to PAP
824 pap.service(httpServletRequest, httpServletResponse);
826 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
829 private void dictionaryTestSetup(Boolean updateFlag, String dictionaryType, String json)
830 throws IOException, SQLException {
831 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
832 Mockito.when(httpServletRequest.getHeader("ClientScope")).thenReturn("dictionaryItem");
833 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
834 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
836 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("update");
838 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
840 Mockito.when(httpServletRequest.getParameter("dictionaryType")).thenReturn(dictionaryType);
841 MockServletInputStream mockInput = new MockServletInputStream(json.getBytes());
842 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
843 Mockito.when(httpServletRequest.getReader()).thenReturn(new BufferedReader(new InputStreamReader(mockInput)));
846 public void setDBDao() throws SQLException {
847 BasicDataSource dataSource = new BasicDataSource();
848 dataSource.setDriverClassName("org.h2.Driver");
849 // In-memory DB for testing
850 dataSource.setUrl("jdbc:h2:mem:test");
851 dataSource.setUsername("sa");
852 dataSource.setPassword("");
853 LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
854 sessionBuilder.scanPackages("org.onap.*", "com.*");
856 Properties properties = new Properties();
857 properties.put("hibernate.show_sql", "false");
858 properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
859 properties.put("hibernate.hbm2ddl.auto", "drop");
860 properties.put("hibernate.hbm2ddl.auto", "create");
862 sessionBuilder.addProperties(properties);
863 sessionFactory = sessionBuilder.buildSessionFactory();
865 // Set up dao with SessionFactory
866 CommonClassDaoImpl.setSessionfactory(sessionFactory);
867 PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
871 public void getDictionary() throws ServletException, IOException {
872 String[] dictionarys = new String[] {"Attribute", "OnapName", "Action", "BRMSParamTemplate", "VSCLAction",
873 "VNFType", "PEPOptions", "Varbind", "Service", "Site", "Settings", "RainyDayTreatments",
874 "DescriptiveScope", "ActionList", "ProtocolList", "Zone", "SecurityZone", "PrefixList", "AddressGroup",
875 "ServiceGroup", "ServiceList", "TermList", "MicroServiceLocation", "MicroServiceConfigName", "DCAEUUID",
876 "MicroServiceModels", "PolicyScopeService", "PolicyScopeResource", "PolicyScopeType",
877 "PolicyScopeClosedLoop", "GroupPolicyScopeList", "RiskType", "SafePolicyWarning",
878 "MicroServiceDictionary"};
879 for (String dictionary : dictionarys) {
880 httpServletRequest = Mockito.mock(HttpServletRequest.class);
881 httpServletResponse = new MockHttpServletResponse();
882 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
883 Mockito.when(httpServletRequest.getMethod()).thenReturn("GET");
884 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
885 Mockito.when(httpServletRequest.getParameter("dictionaryType")).thenReturn(dictionary);
886 pap.service(httpServletRequest, httpServletResponse);
887 assertTrue(HttpServletResponse.SC_OK == httpServletResponse.getStatus());
892 public void testDummy() throws ServletException, IOException {
894 Mockito.when(httpServletRequest.getMethod()).thenReturn("POST");
895 mockOutput = Mockito.mock(ServletOutputStream.class);
898 Mockito.when(httpServletResponse.getOutputStream()).thenReturn(mockOutput);
899 } catch (IOException e) {
904 pap.service(httpServletRequest, httpServletResponse);
906 } catch (Exception e) {
912 public static void destroy() {
913 if (sessionFactory != null) {
914 sessionFactory.close();