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 logger.info(httpServletResponse);
131 Mockito.when(httpServletRequest.getHeaderNames()).thenReturn(Collections.enumeration(headers));
132 Mockito.when(httpServletRequest.getAttributeNames()).thenReturn(Collections.enumeration(headers));
133 CommonClassDaoImpl.setSessionfactory(sessionFactory);
134 PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
138 public void testFirwallCreatePolicy() throws IOException, ServletException, SQLException {
139 httpServletRequest = Mockito.mock(HttpServletRequest.class);
140 String json = "{\"serviceTypeId\":\"/v0/firewall/pan\",\"configName\":\"TestFwPolicyConfig\","
141 + "\"deploymentOption\":{\"deployNow\":false},\"securityZoneId\":\"cloudsite:dev1a\","
142 + "\"serviceGroups\":[{\"name\":\"SSH\",\"description\":\"Sshservice entry in servicelist\","
143 + "\"type\":\"SERVICE\",\"transportProtocol\":\"tcp\",\"appProtocol\":null,\"ports\":\"22\"}],"
144 + "\"addressGroups\":[{\"name\":\"test\",\"description\":\"Destination\","
145 + "\"members\":[{\"type\":\"SUBNET\",\"value\":\"127.0.0.1/12\"}]},{\"name\":\"TestServers\","
146 + "\"description\":\"SourceTestServers for firsttesting\",\"members\":[{\"type\":\"SUBNET\","
147 + "\"value\":\"127.0.0.1/23\"}]}],\"firewallRuleList\":[{\"position\":\"1\","
148 + "\"ruleName\":\"FWRuleTestServerToTest\",\"fromZones\":[\"UntrustedZoneTestName\"],"
149 + "\"toZones\":[\"TrustedZoneTestName\"],\"negateSource\":false,\"negateDestination\":false,"
150 + "\"sourceList\":[{\"type\":\"REFERENCE\",\"name\":\"TestServers\"}],"
151 + "\"destinationList\":[{\"type\":\"REFERENCE\",\"name\":\"Test\"}],\"sourceServices\":[],"
152 + "\"destServices\":[{\"type\":\"REFERENCE\",\"name\":\"SSH\"}],\"action\":\"accept\","
153 + "\"description\":\"FWrule for Test source to Test destination\",\"enabled\":true,"
155 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
156 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
157 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
158 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
159 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
160 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("Firewall Config")
161 .policyName("test").description("testDescription").configName("Test").editPolicy(false).domain("test")
162 .jsonBody(json).highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate("")
164 MockServletInputStream mockInput =
165 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
166 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
167 logger.info(httpServletRequest);
168 logger.info(httpServletResponse);
169 pap.service(httpServletRequest, httpServletResponse);
170 Mockito.verify(httpServletResponse).addHeader("operation", "create");
174 public void testBRMSCreatePolicy() throws IOException, ServletException, SQLException {
175 httpServletRequest = Mockito.mock(HttpServletRequest.class);
176 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
177 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
178 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
179 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
180 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
181 Map<String, String> matchingAttributes = new HashMap<>();
182 Map<String, String> ruleAttributes = new HashMap<>();
183 ruleAttributes.put("templateName", "testPolicy");
184 ruleAttributes.put("samPoll", "5");
185 ruleAttributes.put("value", "test");
186 // Creating BRMS Param Policies from the Admin Console
187 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Param")
188 .policyName("test").description("testing").configName("BRMS_PARAM_RULE").editPolicy(false)
189 .domain("test").dynamicFieldConfigAttributes(matchingAttributes).highestVersion(0).onapName("DROOLS")
190 .configBodyData(null).drlRuleAndUIParams(ruleAttributes).riskLevel("5").riskType("default")
191 .guard("false").ttlDate("").brmsController(null).brmsDependency(null).build());
192 MockServletInputStream mockInput =
193 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
194 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
197 logger.info(httpServletRequest);
198 logger.info(httpServletResponse);
199 pap.service(httpServletRequest, httpServletResponse);
200 Mockito.verify(httpServletResponse).addHeader("operation", "create");
204 public void testBRMSRawCreatePolicy() throws IOException, ServletException, SQLException {
205 httpServletRequest = Mockito.mock(HttpServletRequest.class);
206 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
207 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
208 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
209 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
210 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
211 Map<String, String> ruleAttributes = new HashMap<>();
212 ruleAttributes.put("value", "test");
213 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Raw")
214 .policyName("test").description("testig description").configName("BRMS_RAW_RULE").editPolicy(false)
215 .domain("test").dynamicFieldConfigAttributes(ruleAttributes).highestVersion(0).onapName("DROOLS")
216 .configBodyData("test").riskLevel("4").riskType("default").guard("false").build());
217 MockServletInputStream mockInput =
218 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
219 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
222 logger.info(httpServletRequest);
223 logger.info(httpServletResponse);
224 pap.service(httpServletRequest, httpServletResponse);
225 Mockito.verify(httpServletResponse).addHeader("operation", "create");
229 public void testClosedLoopPMCreatePolicy() throws IOException, ServletException, SQLException {
230 httpServletRequest = Mockito.mock(HttpServletRequest.class);
231 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
232 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
233 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
234 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
235 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
236 String json = "{\"test\":\"java\"}";
237 // Creating CloseLoop_Fault and Performance Metric Policies
238 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("ClosedLoop_PM")
239 .policyName("test").description("testing").onapName("onap").jsonBody(json).draft(false)
240 .oldPolicyFileName(null).serviceType("Registration Failure(Trinity)").editPolicy(false).domain("test")
241 .highestVersion(0).riskLevel(null).riskType("default").guard("true").ttlDate("").build());
242 MockServletInputStream mockInput =
243 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
244 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
247 logger.info(httpServletRequest);
248 logger.info(httpServletResponse);
249 pap.service(httpServletRequest, httpServletResponse);
250 Mockito.verify(httpServletResponse).addHeader("operation", "create");
254 public void testDecisonAAFPolicy() throws IOException, ServletException, SQLException {
255 httpServletRequest = Mockito.mock(HttpServletRequest.class);
256 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
257 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
258 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
259 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
260 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
261 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
262 StdPAPPolicyParams.builder().policyName("test").description("test rule").onapName("ONAP")
263 .providerComboBox("AAF").editPolicy(false).domain("test").highestVersion(0).build());
264 MockServletInputStream mockInput =
265 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
266 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
268 logger.info(httpServletRequest);
269 logger.info(httpServletResponse);
270 pap.service(httpServletRequest, httpServletResponse);
271 Mockito.verify(httpServletResponse).addHeader("operation", "create");
275 public void testDecisonGuardPolicy() throws IOException, ServletException, SQLException {
276 httpServletRequest = Mockito.mock(HttpServletRequest.class);
277 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
278 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
279 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
280 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
281 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
282 Map<String, String> matchingAttributes = new HashMap<>();
283 matchingAttributes.put("actor", "test");
284 matchingAttributes.put("recipe", "restart");
285 matchingAttributes.put("targets", "test,test1");
286 matchingAttributes.put("clname", "");
287 matchingAttributes.put("limit", "1");
288 matchingAttributes.put("timeWindow", "15");
289 matchingAttributes.put("timeUnits", "minute");
290 matchingAttributes.put("guardActiveStart", "05:00");
291 matchingAttributes.put("guardActiveEnd", "10:00");
292 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
293 StdPAPPolicyParams.builder().policyName("testGuard").description("test rule").onapName("PDPD")
294 .providerComboBox("GUARD_YAML").dynamicFieldConfigAttributes(matchingAttributes)
295 .editPolicy(false).domain("test").highestVersion(0).build());
296 MockServletInputStream mockInput =
297 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
298 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
300 logger.info(httpServletRequest);
301 logger.info(httpServletResponse);
302 pap.service(httpServletRequest, httpServletResponse);
303 Mockito.verify(httpServletResponse).addHeader("operation", "create");
307 public void testDecisonGuardMinMaxPolicy() throws IOException, ServletException, SQLException {
308 httpServletRequest = Mockito.mock(HttpServletRequest.class);
309 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
310 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
311 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
312 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
313 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
314 Map<String, String> matchingAttributes = new HashMap<>();
315 matchingAttributes.put("actor", "test");
316 matchingAttributes.put("recipe", "scaleOut");
317 matchingAttributes.put("targets", "test,test1");
318 matchingAttributes.put("clname", "test");
319 matchingAttributes.put("min", "1");
320 matchingAttributes.put("max", "5");
321 matchingAttributes.put("guardActiveStart", "05:00");
322 matchingAttributes.put("guardActiveEnd", "10:00");
323 StdPAPPolicy newPAPPolicy =
325 new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("testGuardMinMax").description("test rule")
326 .onapName("PDPD").providerComboBox("GUARD_MIN_MAX")
327 .dynamicFieldConfigAttributes(matchingAttributes).editPolicy(false).domain("test")
328 .highestVersion(0).build());
329 MockServletInputStream mockInput =
330 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
331 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
333 logger.info(httpServletRequest);
334 logger.info(httpServletResponse);
335 pap.service(httpServletRequest, httpServletResponse);
336 Mockito.verify(httpServletResponse).addHeader("operation", "create");
341 public void testDecisonBLGuardPolicy() throws IOException, ServletException, SQLException {
342 httpServletRequest = Mockito.mock(HttpServletRequest.class);
343 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
344 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
345 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
346 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
347 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
348 Map<String, String> matchingAttributes = new HashMap<>();
349 matchingAttributes.put("actor", "test");
350 matchingAttributes.put("recipe", "restart");
351 matchingAttributes.put("clname", "test");
352 matchingAttributes.put("guardActiveStart", "05:00");
353 matchingAttributes.put("guardActiveEnd", "10:00");
354 matchingAttributes.put("blackList", "bl1,bl2");
355 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
356 StdPAPPolicyParams.builder().policyName("testblGuard").description("test rule").onapName("PDPD")
357 .providerComboBox("GUARD_BL_YAML").dynamicFieldConfigAttributes(matchingAttributes)
358 .editPolicy(false).domain("test").highestVersion(0).build());
359 MockServletInputStream mockInput =
360 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
361 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
363 logger.info(httpServletRequest);
364 logger.info(httpServletResponse);
365 pap.service(httpServletRequest, httpServletResponse);
366 Mockito.verify(httpServletResponse).addHeader("operation", "create");
370 public void testConfigPolicy() throws IOException, ServletException, SQLException {
371 httpServletRequest = Mockito.mock(HttpServletRequest.class);
372 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
373 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
374 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
375 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
376 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
377 Map<String, String> configAttributes = new HashMap<>();
378 configAttributes.put("value", "test");
379 StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
380 StdPAPPolicyParams.builder().configPolicyType("Base").policyName("test").description("test rule")
381 .onapName("TEST").configName("config").dynamicFieldConfigAttributes(configAttributes)
382 .configType("OTHER").configBodyData("test body").editPolicy(false).domain("test")
383 .highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate(null).build());
384 MockServletInputStream mockInput =
385 new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
386 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
388 logger.info(httpServletRequest);
389 logger.info(httpServletResponse);
390 pap.service(httpServletRequest, httpServletResponse);
391 Mockito.verify(httpServletResponse).addHeader("operation", "create");
395 public void testActionPolicy() throws IOException, ServletException, SQLException {
397 httpServletRequest = Mockito.mock(HttpServletRequest.class);
398 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
399 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
400 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("API");
401 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
402 Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Action");
404 CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
405 PolicyCreation.setCommonClassDao(commonClassDao);
406 ActionPolicyDict actionDict = new ActionPolicyDict();
407 actionDict.setBody("{\"test\":\"test\"}");
408 actionDict.setHeader("test122=test12:test22=test34");
409 actionDict.setType("REST");
410 actionDict.setMethod("GET");
411 actionDict.setUrl("testsomeurl.com");
412 Mockito.when(commonClassDao.getEntityItem(ActionPolicyDict.class, "attributeName", "test"))
413 .thenReturn(actionDict);
414 FunctionDefinition funcDefn = new FunctionDefinition();
415 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:and");
416 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "and")).thenReturn(funcDefn);
417 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-equal");
418 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-equal"))
419 .thenReturn(funcDefn);
420 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:3.0:function:string-contains");
421 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "string-contains"))
422 .thenReturn(funcDefn);
423 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-greater-than");
424 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-greater-than"))
425 .thenReturn(funcDefn);
426 funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:or");
427 Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "or")).thenReturn(funcDefn);
429 Map<String, String> componentAttributes = new HashMap<>();
430 componentAttributes.put("java", "test");
431 StdPAPPolicy newPapPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("test").description("test")
432 .dynamicFieldConfigAttributes(componentAttributes)
433 .dynamicRuleAlgorithmLabels(Arrays.asList("A1", "A2", "A3", "A4", "A5", "A6", "A7"))
434 .dynamicRuleAlgorithmCombo(Arrays.asList("integer-equal", "string-contains", "integer-equal", "and",
435 "integer-greater-than", "or", "and"))
436 .dynamicRuleAlgorithmField1(Arrays.asList("cobal", "cap", "cobal", "A2", "Config", "A4", "A1"))
437 .dynamicRuleAlgorithmField2(Arrays.asList("90", "ca", "90", "A3", "45", "A5", "A6"))
438 .actionPerformer("PDP").actionAttribute("test").editPolicy(false).domain("com").highestVersion(0)
440 newPapPolicy.setActionBody("{\"test\":\"test\"}");
442 MockServletInputStream mockInput =
443 new MockServletInputStream(PolicyUtils.objectToJsonString(newPapPolicy).getBytes());
444 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
446 logger.info(httpServletRequest);
447 logger.info(httpServletResponse);
448 pap.service(httpServletRequest, httpServletResponse);
449 Mockito.verify(httpServletResponse).addHeader("operation", "create");
453 private void setPolicyCreation() {
454 CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
455 PolicyCreation.setCommonClassDao(commonClassDao);
456 PolicyEditorScopes editorScope = new PolicyEditorScopes();
457 UserInfo userInfo = new UserInfo();
458 userInfo.setUserName("API");
459 userInfo.setUserLoginId("API");
460 editorScope.setScopeName("test");
461 editorScope.setUserCreatedBy(userInfo);
462 editorScope.setUserModifiedBy(userInfo);
463 Mockito.when(commonClassDao.getEntityItem(PolicyEditorScopes.class, "scopeName", "test"))
464 .thenReturn(editorScope);
465 BRMSParamTemplate template = new BRMSParamTemplate();
466 template.setRuleName("testPolicy");
467 template.setUserCreatedBy(userInfo);
468 String rule = "package com.sample;\n" + "import com.sample.DroolsTest.Message;\n" + "declare Params\n"
469 + "samPoll : int\n" + "value : String\n" + "end\n" + "///This Rule will be generated by the UI.\n"
470 + "rule \"${policyName}.Create parameters structure\"\n" + "salience 1000 \n" + "when\n" + "then\n"
471 + "Params params = new Params();\n" + "params.setSamPoll(76);\n" + "params.setValue(\"test\");\n"
472 + "insertLogical(params);\n" + "end\n"
473 + "rule \"Rule 1: Check parameter structure access from when/then\"\n" + "when\n" + "$param: Params()\n"
474 + "Params($param.samPoll > 50)\n" + "then\n" + "System.out.println(\"Firing rule 1\");\n"
475 + "System.out.println($param);\n" + "end\n";
476 template.setRule(rule);
477 Mockito.when(commonClassDao.getEntityItem(BRMSParamTemplate.class, "ruleName", "testPolicy"))
478 .thenReturn(template);
482 public void testClosedLoopCreateDictionary() throws IOException, SQLException, ServletException {
483 httpServletRequest = Mockito.mock(HttpServletRequest.class);
485 String json = "{\"dictionaryFields\": {\"vsclaction\": \"testRestAPI\",\"description\": \"testing create\"}}";
486 dictionaryTestSetup(false, "VSCLAction", json);
488 ClosedLoopDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
489 // send Request to PAP
490 pap.service(httpServletRequest, httpServletResponse);
492 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
496 httpServletRequest = Mockito.mock(HttpServletRequest.class);
497 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
498 json = "{\"dictionaryFields\": {\"vnftype\": \"testrestAPI1\",\"description\": \"testing create\"}}";
499 dictionaryTestSetup(false, "VNFType", json);
500 // send Request to PAP
501 pap.service(httpServletRequest, httpServletResponse);
503 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
507 httpServletRequest = Mockito.mock(HttpServletRequest.class);
508 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
509 json = "{\"dictionaryFields\":{\"pepName\":\"testRestAPI\",\"description\":\"testing create\","
510 + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
511 + "\"number\":\"test\"}]}}";
512 dictionaryTestSetup(false, "PEPOptions", json);
513 // send Request to PAP
514 pap.service(httpServletRequest, httpServletResponse);
516 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
520 httpServletRequest = Mockito.mock(HttpServletRequest.class);
521 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
522 json = "{\"dictionaryFields\":{\"varbindName\":\"testRestAPI\",\"varbindDescription\":\"testing\","
523 + "\"varbindOID\":\"test\"}}";
524 dictionaryTestSetup(false, "Varbind", json);
525 // send Request to PAP
526 pap.service(httpServletRequest, httpServletResponse);
528 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
532 httpServletRequest = Mockito.mock(HttpServletRequest.class);
533 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
534 json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPI\",\"description\":\"testing\"}}";
535 dictionaryTestSetup(false, "Service", json);
536 // send Request to PAP
537 pap.service(httpServletRequest, httpServletResponse);
539 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
543 httpServletRequest = Mockito.mock(HttpServletRequest.class);
544 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
545 json = "{\"dictionaryFields\":{\"siteName\":\"testRestAPI\",\"description\":\"testing\"}}";
546 dictionaryTestSetup(false, "Site", json);
547 // send Request to PAP
548 pap.service(httpServletRequest, httpServletResponse);
550 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
554 public void testFirewallCreateDictionary() throws IOException, SQLException, ServletException {
555 httpServletRequest = Mockito.mock(HttpServletRequest.class);
556 // Check SecurityZone.
557 String json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"testing\"}}";
558 dictionaryTestSetup(false, "SecurityZone", json);
560 FirewallDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
561 // send Request to PAP
562 pap.service(httpServletRequest, httpServletResponse);
564 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
568 httpServletRequest = Mockito.mock(HttpServletRequest.class);
569 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
570 json = "{\"dictionaryFields\":{\"actionName\":\"testRestAPI\",\"description\":\"test\"}}";
571 dictionaryTestSetup(false, "ActionList", json);
572 // send Request to PAP
573 pap.service(httpServletRequest, httpServletResponse);
575 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
577 // Check Protocol List.
579 httpServletRequest = Mockito.mock(HttpServletRequest.class);
580 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
581 json = "{\"dictionaryFields\":{\"protocolName\":\"testRestAPI\",\"description\":\"test\"}}";
582 dictionaryTestSetup(false, "ProtocolList", json);
583 // send Request to PAP
584 pap.service(httpServletRequest, httpServletResponse);
586 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
590 httpServletRequest = Mockito.mock(HttpServletRequest.class);
591 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
592 json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"test\"}}";
593 dictionaryTestSetup(false, "Zone", json);
594 // send Request to PAP
595 pap.service(httpServletRequest, httpServletResponse);
597 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
601 httpServletRequest = Mockito.mock(HttpServletRequest.class);
602 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
603 json = "{\"dictionaryFields\":{\"prefixListName\":\"testRestAPI\",\"prefixListValue\":\"127.0.0.1\","
604 + "\"description\":\"testing\"}}";
605 dictionaryTestSetup(false, "PrefixList", json);
606 // send Request to PAP
607 pap.service(httpServletRequest, httpServletResponse);
609 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
611 // Check AddressGroup.
613 httpServletRequest = Mockito.mock(HttpServletRequest.class);
614 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
615 json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIgroup\",\"description\":\"testing\","
616 + "\"attributes\":[{\"option\":\"testRestAPI\"}, {\"option\":\"testRestAPI\"}]}}";
617 dictionaryTestSetup(false, "AddressGroup", json);
618 // send Request to PAP
619 pap.service(httpServletRequest, httpServletResponse);
621 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
623 // Check ServiceGroup.
625 httpServletRequest = Mockito.mock(HttpServletRequest.class);
626 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
627 json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIServiceGroup\","
628 + "\"attributes\":[{\"option\":\"testRestAPIservice\"}]}}";
629 dictionaryTestSetup(false, "ServiceGroup", json);
630 // send Request to PAP
631 pap.service(httpServletRequest, httpServletResponse);
633 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
635 // Check ServiceList.
637 httpServletRequest = Mockito.mock(HttpServletRequest.class);
638 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
639 json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPIservice\",\"serviceDescription\":\"test\","
640 + "\"servicePorts\":\"8888\",\"transportProtocols\":[{\"option\":\"testRestAPI\"},"
641 + "{\"option\":\"testRestAPI1\"}],\"appProtocols\":[{\"option\":\"testRestAPI\"},"
642 + "{\"option\":\"testRestAPI1\"}]}}";
643 dictionaryTestSetup(false, "ServiceList", json);
644 // send Request to PAP
645 pap.service(httpServletRequest, httpServletResponse);
647 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
651 httpServletRequest = Mockito.mock(HttpServletRequest.class);
652 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
653 json = "{\"dictionaryFields\":{\"termName\":\"testRestAPIRule\",\"termDescription\":\"testing\","
654 + "\"fromZoneDatas\":[{\"option\":\"testRestAPI\"}],"
655 + "\"toZoneDatas\":[{\"option\":\"testRestAPI1\"}],"
656 + "\"sourceListDatas\":[{\"option\":\"Group_testportal\"}],"
657 + "\"destinationListDatas\":[{\"option\":\"testRestAPI\"}],"
658 + "\"sourceServiceDatas\":[{\"option\":\"testRestAPIservice\"},"
659 + "{\"option\":\"testRestAPIservice1\"}],"
660 + "\"destinationServiceDatas\":[{\"option\":\"testRestAPIservice1\"},"
661 + "{\"option\":\"testportalservice2\"}],\"actionListDatas\":[{\"option\":\"testRestAPI\"}]}}";
662 dictionaryTestSetup(false, "TermList", json);
663 // send Request to PAP
664 pap.service(httpServletRequest, httpServletResponse);
666 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
670 public void testCommonCreateDictionary() throws IOException, SQLException, ServletException {
671 new DictionaryController(commonClassDao);
672 new ActionPolicyDictionaryController(commonClassDao);
673 new SafePolicyController(commonClassDao);
674 new DescriptiveDictionaryController(commonClassDao);
675 List<Object> object = new ArrayList<>();
676 object.add(new Category());
677 when(commonClassDao.getDataById(Category.class, "shortName", "resource")).thenReturn(object);
678 httpServletRequest = Mockito.mock(HttpServletRequest.class);
679 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
681 "{\"dictionaryFields\": {\"onapName\": \"testMMRestAPI1\",\"description\": \"testing update response "
683 dictionaryTestSetup(false, "OnapName", json);
684 // send Request to PAP
685 pap.service(httpServletRequest, httpServletResponse);
687 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
689 httpServletRequest = Mockito.mock(HttpServletRequest.class);
690 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
691 json = "{\"dictionaryFields\": {\"xacmlId\": \"testMMRestAPI1\",\"datatypeBean\": {\"shortName\": "
692 + "\"string\"}, \"description\": \"testing update\",\"priority\": \"High\","
693 + "\"userDataTypeValues\": [{\"attributeValues\": \"testAttr\"}, {\"attributeValues\": "
694 + "\"testAttr2\"}, {\"attributeValues\": \"testAttr3\"}]}}";
695 dictionaryTestSetup(false, "Attribute", json);
696 // send Request to PAP
697 pap.service(httpServletRequest, httpServletResponse);
699 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
702 httpServletRequest = Mockito.mock(HttpServletRequest.class);
703 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
704 json = "{\"dictionaryFields\":{\"attributeName\":\"TestMMrestAPI1\",\"type\":\"REST\",\"url\":\"testsomeurl"
705 + ".com\",\"method\":\"GET\",\"description\":\"test create\",\"body\":\"Testing Create\","
706 + "\"headers\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
707 + "\"number\":\"test\"}]}}";
708 dictionaryTestSetup(false, "Action", 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\":{\"scopeName\":\"testMMRestAPI1\",\"description\":\"test\","
717 + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
718 + "\"number\":\"test\"}]}}";
719 dictionaryTestSetup(false, "DescriptiveScope", json);
720 // send Request to PAP
721 pap.service(httpServletRequest, httpServletResponse);
723 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
725 httpServletRequest = Mockito.mock(HttpServletRequest.class);
726 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
727 json = "{\"dictionaryFields\":{\"riskName\":\"testMMrestAPI1\",\"description\":\"test\"}}";
728 dictionaryTestSetup(false, "RiskType", json);
729 // send Request to PAP
730 pap.service(httpServletRequest, httpServletResponse);
732 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
734 httpServletRequest = Mockito.mock(HttpServletRequest.class);
735 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
736 json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"message\":\"test\","
737 + "\"riskType\":\"testMMrestAPI1\"}}";
738 dictionaryTestSetup(false, "SafePolicyWarning", json);
739 // send Request to PAP
740 pap.service(httpServletRequest, httpServletResponse);
742 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
746 public void testDecisionCreateDictionary() throws IOException, SQLException, ServletException {
747 new DecisionPolicyDictionaryController(commonClassDao);
748 httpServletRequest = Mockito.mock(HttpServletRequest.class);
749 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
751 "{\"dictionaryFields\":{\"xacmlId\":\"testMMRestAPI1\",\"datatypeBean\":{\"shortName\":\"string\"},"
752 + "\"description\":\"test\",\"priority\":\"High\"}}";
753 dictionaryTestSetup(false, "Settings", json);
754 // send Request to PAP
755 pap.service(httpServletRequest, httpServletResponse);
757 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
759 httpServletRequest = Mockito.mock(HttpServletRequest.class);
760 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
761 json = "{\"dictionaryFields\":{\"bbid\":\"BB1\",\"workstep\":\"1\",\"treatments\":\"Manual Handling,Abort,"
763 dictionaryTestSetup(false, "RainyDayTreatments", json);
764 // send Request to PAP
765 pap.service(httpServletRequest, httpServletResponse);
767 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
771 public void testMSCreateDictionary() throws IOException, SQLException, ServletException {
772 new MicroServiceDictionaryController(commonClassDao);
773 new PolicyScopeDictionaryController(commonClassDao);
774 httpServletRequest = Mockito.mock(HttpServletRequest.class);
775 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
776 String json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"descriptionValue\":\"test\"}}";
777 dictionaryTestSetup(false, "MicroServiceLocation", json);
778 // send Request to PAP
779 pap.service(httpServletRequest, httpServletResponse);
781 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
783 httpServletRequest = Mockito.mock(HttpServletRequest.class);
784 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
785 json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"descriptionValue\":\"test\"}}";
786 dictionaryTestSetup(false, "MicroServiceConfigName", json);
787 // send Request to PAP
788 pap.service(httpServletRequest, httpServletResponse);
790 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
792 httpServletRequest = Mockito.mock(HttpServletRequest.class);
793 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
794 json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"description\":\"test\"}}";
795 dictionaryTestSetup(false, "DCAEUUID", json);
796 // send Request to PAP
797 pap.service(httpServletRequest, httpServletResponse);
799 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
801 httpServletRequest = Mockito.mock(HttpServletRequest.class);
802 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
803 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
804 dictionaryTestSetup(false, "PolicyScopeService", json);
805 // send Request to PAP
806 pap.service(httpServletRequest, httpServletResponse);
808 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
810 httpServletRequest = Mockito.mock(HttpServletRequest.class);
811 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
812 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
813 dictionaryTestSetup(false, "PolicyScopeResource", json);
814 // send Request to PAP
815 pap.service(httpServletRequest, httpServletResponse);
817 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
819 httpServletRequest = Mockito.mock(HttpServletRequest.class);
820 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
821 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
822 dictionaryTestSetup(false, "PolicyScopeType", json);
823 // send Request to PAP
824 pap.service(httpServletRequest, httpServletResponse);
826 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
828 httpServletRequest = Mockito.mock(HttpServletRequest.class);
829 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
830 json = "{\"dictionaryFields\":{\"name\":\"testApiANY\",\"descriptionValue\":\"default test\"}}";
831 dictionaryTestSetup(false, "PolicyScopeClosedLoop", json);
832 // send Request to PAP
833 pap.service(httpServletRequest, httpServletResponse);
835 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
837 httpServletRequest = Mockito.mock(HttpServletRequest.class);
838 httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
839 json = "{\"dictionaryFields\":{\"groupName\":\"testMMrestAPI1\",\"description\":\"testing\"},"
840 + "\"groupPolicyScopeListData1\":{\"resource\":\"ANY\",\"type\":\"ANY\",\"service\":\"ANY\","
841 + "\"closedloop\":\"ANY\"}}";
842 dictionaryTestSetup(false, "GroupPolicyScopeList", json);
843 // send Request to PAP
844 pap.service(httpServletRequest, httpServletResponse);
846 Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
849 private void dictionaryTestSetup(Boolean updateFlag, String dictionaryType, String json)
850 throws IOException, SQLException {
851 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
852 Mockito.when(httpServletRequest.getHeader("ClientScope")).thenReturn("dictionaryItem");
853 Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
854 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
856 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("update");
858 Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
860 Mockito.when(httpServletRequest.getParameter("dictionaryType")).thenReturn(dictionaryType);
861 MockServletInputStream mockInput = new MockServletInputStream(json.getBytes());
862 Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
863 Mockito.when(httpServletRequest.getReader()).thenReturn(new BufferedReader(new InputStreamReader(mockInput)));
866 public void setDBDao() throws SQLException {
867 BasicDataSource dataSource = new BasicDataSource();
868 dataSource.setDriverClassName("org.h2.Driver");
869 // In-memory DB for testing
870 dataSource.setUrl("jdbc:h2:mem:test");
871 dataSource.setUsername("sa");
872 dataSource.setPassword("");
873 LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
874 sessionBuilder.scanPackages("org.onap.*", "com.*");
876 Properties properties = new Properties();
877 properties.put("hibernate.show_sql", "false");
878 properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
879 properties.put("hibernate.hbm2ddl.auto", "drop");
880 properties.put("hibernate.hbm2ddl.auto", "create");
882 sessionBuilder.addProperties(properties);
883 sessionFactory = sessionBuilder.buildSessionFactory();
885 // Set up dao with SessionFactory
886 CommonClassDaoImpl.setSessionfactory(sessionFactory);
887 PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
891 public void getDictionary() throws ServletException, IOException {
892 String[] dictionarys = new String[] {"Attribute", "OnapName", "Action", "BRMSParamTemplate", "VSCLAction",
893 "VNFType", "PEPOptions", "Varbind", "Service", "Site", "Settings", "RainyDayTreatments",
894 "DescriptiveScope", "ActionList", "ProtocolList", "Zone", "SecurityZone", "PrefixList", "AddressGroup",
895 "ServiceGroup", "ServiceList", "TermList", "MicroServiceLocation", "MicroServiceConfigName", "DCAEUUID",
896 "MicroServiceModels", "PolicyScopeService", "PolicyScopeResource", "PolicyScopeType",
897 "PolicyScopeClosedLoop", "GroupPolicyScopeList", "RiskType", "SafePolicyWarning",
898 "MicroServiceDictionary"};
899 for (String dictionary : dictionarys) {
900 httpServletRequest = Mockito.mock(HttpServletRequest.class);
901 httpServletResponse = new MockHttpServletResponse();
902 Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
903 Mockito.when(httpServletRequest.getMethod()).thenReturn("GET");
904 Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
905 Mockito.when(httpServletRequest.getParameter("dictionaryType")).thenReturn(dictionary);
906 pap.service(httpServletRequest, httpServletResponse);
907 assertTrue(HttpServletResponse.SC_OK == httpServletResponse.getStatus());
912 public void testDummy() throws ServletException, IOException {
914 Mockito.when(httpServletRequest.getMethod()).thenReturn("POST");
915 mockOutput = Mockito.mock(ServletOutputStream.class);
918 Mockito.when(httpServletResponse.getOutputStream()).thenReturn(mockOutput);
919 } catch (IOException e) {
920 fail(e.getMessage());
924 pap.service(httpServletRequest, httpServletResponse);
926 } catch (Exception e) {
927 fail(e.getMessage());
932 public static void destroy() {
933 if (sessionFactory != null) {
934 sessionFactory.close();