* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
- * Modified Copyright (C) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2018 Samsung Electronics Co., Ltd.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.junit.Assert.fail;
import static org.mockito.Mockito.when;
+import com.mockrunner.mock.web.MockServletInputStream;
+
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.SQLException;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.EntityTransaction;
-import javax.persistence.Persistence;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import org.apache.commons.logging.LogFactory;
import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
import org.hibernate.SessionFactory;
-import org.junit.After;
+import org.junit.AfterClass;
import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
-import org.onap.policy.common.ia.IntegrityAuditProperties;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.pap.xacml.rest.components.FirewallConfigPolicy;
+import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTest;
import org.onap.policy.pap.xacml.rest.controller.ActionPolicyDictionaryController;
import org.onap.policy.pap.xacml.rest.controller.ClosedLoopDictionaryController;
import org.onap.policy.pap.xacml.rest.controller.DecisionPolicyDictionaryController;
import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
import org.onap.policy.rest.dao.CommonClassDao;
-import org.onap.policy.rest.jpa.BRMSParamTemplate;
+import org.onap.policy.rest.jpa.ActionPolicyDict;
+import org.onap.policy.rest.jpa.BrmsParamTemplate;
import org.onap.policy.rest.jpa.Category;
+import org.onap.policy.rest.jpa.FunctionDefinition;
import org.onap.policy.rest.jpa.PolicyEditorScopes;
import org.onap.policy.rest.jpa.UserInfo;
import org.onap.policy.utils.PolicyUtils;
import org.springframework.mock.web.MockServletConfig;
import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
-import com.mockrunner.mock.web.MockServletInputStream;
-
public class XACMLPAPTest {
private static final Log logger = LogFactory.getLog(XACMLPAPTest.class);
private static final String ENVIRONMENT_HEADER = "Environment";
- private List<String> headers = new ArrayList<>();
+ private static List<String> headers = new ArrayList<>();
private HttpServletRequest httpServletRequest;
private HttpServletResponse httpServletResponse;
private ServletOutputStream mockOutput;
- private ServletConfig servletConfig;
- private XACMLPapServlet pap;
- private SessionFactory sessionFactory;
- private CommonClassDao commonClassDao;
-
- private static final String DEFAULT_DB_DRIVER = "org.h2.Driver";
- private static final String DEFAULT_DB_USER = "sa";
- private static final String DEFAULT_DB_PWD = "";
-
- @Before
- public void setUpDB() throws Exception {
- logger.info("setUpDB: Entering");
-
- Properties properties = new Properties();
- properties.put(IntegrityAuditProperties.DB_DRIVER, XACMLPAPTest.DEFAULT_DB_DRIVER);
- properties.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/xacmlTest");
- properties.put(IntegrityAuditProperties.DB_USER, XACMLPAPTest.DEFAULT_DB_USER);
- properties.put(IntegrityAuditProperties.DB_PWD, XACMLPAPTest.DEFAULT_DB_PWD);
- properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
- properties.put(IntegrityAuditProperties.NODE_TYPE, "pap");
-
- //Clean the iaTest DB table for IntegrityAuditEntity entries
- cleanDb("testPapPU", properties);
-
- logger.info("setUpDB: Exiting");
- }
-
- public void cleanDb(String persistenceUnit, Properties properties) {
- logger.debug("cleanDb: enter");
-
- EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
-
- EntityManager em = emf.createEntityManager();
- // Start a transaction
- EntityTransaction et = em.getTransaction();
-
- et.begin();
-
- // Clean up the DB
- em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
-
- // commit transaction
- et.commit();
- em.close();
- logger.debug("cleanDb: exit");
+ private static ServletConfig servletConfig;
+ private static XACMLPapServlet pap;
+ private static SessionFactory sessionFactory;
+ private static CommonClassDao commonClassDao;
+
+ @BeforeClass
+ public static void beforeClassSetup() throws ServletException {
+ sessionFactory = PolicyDBDaoTest.setupH2DbDaoImpl("xacmlpaptest");
+ new FirewallConfigPolicy(new CommonClassDaoImpl());
+ new DictionaryUtils(new CommonClassDaoImpl());
+ setUp();
}
- @Before
- public void setUp() throws ServletException {
- httpServletRequest = Mockito.mock(HttpServletRequest.class);
- httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- Mockito.when(httpServletRequest.getHeaderNames()).thenReturn(Collections.enumeration(headers));
- Mockito.when(httpServletRequest.getAttributeNames()).thenReturn(Collections.enumeration(headers));
-
+ public static void setUp() throws ServletException {
servletConfig = Mockito.mock(MockServletConfig.class);
System.setProperty("com.sun.management.jmxremote.port", "9993");
Mockito.when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
commonClassDao = Mockito.mock(CommonClassDao.class);
new DictionaryUtils(commonClassDao);
DictionaryUtils.setDictionaryUtils(new DictionaryUtils());
+ UserInfo user = new UserInfo();
+ user.setUserLoginId("API");
+ user.setUserName("API");
+ Mockito.when(commonClassDao.getEntityItem(UserInfo.class, "userLoginId", "API")).thenReturn(user);
Mockito.mock(DictionaryUtils.class);
}
+ @Before
+ public void testInit() {
+ httpServletRequest = Mockito.mock(HttpServletRequest.class);
+ httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
+ logger.info(httpServletResponse);
+ Mockito.when(httpServletRequest.getHeaderNames()).thenReturn(Collections.enumeration(headers));
+ Mockito.when(httpServletRequest.getAttributeNames()).thenReturn(Collections.enumeration(headers));
+ CommonClassDaoImpl.setSessionfactory(sessionFactory);
+ PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
+ }
+
@Test
public void testFirwallCreatePolicy() throws IOException, ServletException, SQLException {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
- String json =
- "{\"serviceTypeId\":\"/v0/firewall/pan\",\"configName\":\"TestFwPolicyConfig\"," +
- "\"deploymentOption\":{\"deployNow\":false},\"securityZoneId\":\"cloudsite:dev1a\"," +
- "\"serviceGroups\":[{\"name\":\"SSH\",\"description\":\"Sshservice entry in servicelist\"," +
- "\"type\":\"SERVICE\",\"transportProtocol\":\"tcp\",\"appProtocol\":null,\"ports\":\"22\"}]," +
- "\"addressGroups\":[{\"name\":\"test\",\"description\":\"Destination\"," +
- "\"members\":[{\"type\":\"SUBNET\",\"value\":\"127.0.0.1/12\"}]},{\"name\":\"TestServers\"," +
- "\"description\":\"SourceTestServers for firsttesting\",\"members\":[{\"type\":\"SUBNET\"," +
- "\"value\":\"127.0.0.1/23\"}]}],\"firewallRuleList\":[{\"position\":\"1\"," +
- "\"ruleName\":\"FWRuleTestServerToTest\",\"fromZones\":[\"UntrustedZoneTestName\"]," +
- "\"toZones\":[\"TrustedZoneTestName\"],\"negateSource\":false,\"negateDestination\":false," +
- "\"sourceList\":[{\"type\":\"REFERENCE\",\"name\":\"TestServers\"}]," +
- "\"destinationList\":[{\"type\":\"REFERENCE\",\"name\":\"Test\"}],\"sourceServices\":[]," +
- "\"destServices\":[{\"type\":\"REFERENCE\",\"name\":\"SSH\"}],\"action\":\"accept\"," +
- "\"description\":\"FWrule for Test source to Test destination\",\"enabled\":true," +
- "\"log\":true}]}";
+ String json = "{\"serviceTypeId\":\"/v0/firewall/pan\",\"configName\":\"TestFwPolicyConfig\","
+ + "\"deploymentOption\":{\"deployNow\":false},\"securityZoneId\":\"cloudsite:dev1a\","
+ + "\"serviceGroups\":[{\"name\":\"SSH\",\"description\":\"Sshservice entry in servicelist\","
+ + "\"type\":\"SERVICE\",\"transportProtocol\":\"tcp\",\"appProtocol\":null,\"ports\":\"22\"}],"
+ + "\"addressGroups\":[{\"name\":\"test\",\"description\":\"Destination\","
+ + "\"members\":[{\"type\":\"SUBNET\",\"value\":\"127.0.0.1/12\"}]},{\"name\":\"TestServers\","
+ + "\"description\":\"SourceTestServers for firsttesting\",\"members\":[{\"type\":\"SUBNET\","
+ + "\"value\":\"127.0.0.1/23\"}]}],\"firewallRuleList\":[{\"position\":\"1\","
+ + "\"ruleName\":\"FWRuleTestServerToTest\",\"fromZones\":[\"UntrustedZoneTestName\"],"
+ + "\"toZones\":[\"TrustedZoneTestName\"],\"negateSource\":false,\"negateDestination\":false,"
+ + "\"sourceList\":[{\"type\":\"REFERENCE\",\"name\":\"TestServers\"}],"
+ + "\"destinationList\":[{\"type\":\"REFERENCE\",\"name\":\"Test\"}],\"sourceServices\":[],"
+ + "\"destServices\":[{\"type\":\"REFERENCE\",\"name\":\"SSH\"}],\"action\":\"accept\","
+ + "\"description\":\"FWrule for Test source to Test destination\",\"enabled\":true,"
+ + "\"log\":true}]}";
Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
- StdPAPPolicy newPAPPolicy =
- new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("Firewall Config")
- .policyName("test")
- .description("testDescription")
- .configName("Test")
- .editPolicy(false)
- .domain("test")
- .jsonBody(json)
- .highestVersion(0)
- .riskLevel("5")
- .riskType("default")
- .guard("false")
- .ttlDate("")
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("Firewall Config")
+ .policyName("test").description("testDescription").configName("Test").editPolicy(false).domain("test")
+ .jsonBody(json).highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate("")
+ .build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
-
- // set DBDao
- setDBDao();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_FW_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
ruleAttributes.put("templateName", "testPolicy");
ruleAttributes.put("samPoll", "5");
ruleAttributes.put("value", "test");
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy("BRMS_Param", "test", "testing",
- "BRMS_PARAM_RULE", false, "test",
- matchingAttributes, 0, "DROOLS",
- null, ruleAttributes, "5",
- "default", "false", "", null, null);
+ // Creating BRMS Param Policies from the Admin Console
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Param")
+ .policyName("test").description("testing").configName("BRMS_PARAM_RULE").editPolicy(false)
+ .domain("test").dynamicFieldConfigAttributes(matchingAttributes).highestVersion(0).onapName("DROOLS")
+ .configBodyData(null).drlRuleAndUIParams(ruleAttributes).riskLevel("5").riskType("default")
+ .guard("false").ttlDate("").brmsController(null).brmsDependency(null).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
setPolicyCreation();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_BRMS_Param_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
Map<String, String> ruleAttributes = new HashMap<>();
ruleAttributes.put("value", "test");
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("BRMS_Raw")
- .policyName("test")
- .description("testig description")
- .configName("BRMS_RAW_RULE")
- .editPolicy(false)
- .domain("test")
- .dynamicFieldConfigAttributes(ruleAttributes)
- .highestVersion(0)
- .onapName("DROOLS")
- .configBodyData("test")
- .riskLevel("4")
- .riskType("default")
- .guard("false")
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Raw")
+ .policyName("test").description("testig description").configName("BRMS_RAW_RULE").editPolicy(false)
+ .domain("test").dynamicFieldConfigAttributes(ruleAttributes).highestVersion(0).onapName("DROOLS")
+ .configBodyData("test").riskLevel("4").riskType("default").guard("false").build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
setPolicyCreation();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_BRMS_Raw_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
String json = "{\"test\":\"java\"}";
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy("ClosedLoop_PM", "test", "testing", "onap",
- json, false, null, "Registration Failure(Trinity)", false, "test", 0, null,
- "default", "true", "");
+ // Creating CloseLoop_Fault and Performance Metric Policies
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("ClosedLoop_PM")
+ .policyName("test").description("testing").onapName("onap").jsonBody(json).draft(false)
+ .oldPolicyFileName(null).serviceType("Registration Failure(Trinity)").editPolicy(false).domain("test")
+ .highestVersion(0).riskLevel(null).riskType("default").guard("true").ttlDate("").build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
setPolicyCreation();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_PM_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .policyName("test")
- .description("test rule")
- .onapName("ONAP")
- .providerComboBox("AAF")
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().policyName("test").description("test rule").onapName("ONAP")
+ .providerComboBox("AAF").editPolicy(false).domain("test").highestVersion(0).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Decision_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
matchingAttributes.put("timeUnits", "minute");
matchingAttributes.put("guardActiveStart", "05:00");
matchingAttributes.put("guardActiveEnd", "10:00");
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().policyName("testGuard").description("test rule").onapName("PDPD")
+ .providerComboBox("GUARD_YAML").dynamicFieldConfigAttributes(matchingAttributes)
+ .editPolicy(false).domain("test").highestVersion(0).build());
+ MockServletInputStream mockInput =
+ new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
+ Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
+
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
+ pap.service(httpServletRequest, httpServletResponse);
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
+ }
+
+ @Test
+ public void testDecisonGuardMinMaxPolicy() throws IOException, ServletException, SQLException {
+ httpServletRequest = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
+ Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
+ Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
+ Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
+ Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
+ Map<String, String> matchingAttributes = new HashMap<>();
+ matchingAttributes.put("actor", "test");
+ matchingAttributes.put("recipe", "scaleOut");
+ matchingAttributes.put("targets", "test,test1");
+ matchingAttributes.put("clname", "test");
+ matchingAttributes.put("min", "1");
+ matchingAttributes.put("max", "5");
+ matchingAttributes.put("guardActiveStart", "05:00");
+ matchingAttributes.put("guardActiveEnd", "10:00");
StdPAPPolicy newPAPPolicy =
- new StdPAPPolicy(StdPAPPolicyParams.builder()
- .policyName("testGuard")
- .description("test rule")
- .onapName("PDPD")
- .providerComboBox("GUARD_YAML")
- .dynamicFieldConfigAttributes(matchingAttributes)
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .build());
+ new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("testGuardMinMax").description("test rule")
+ .onapName("PDPD").providerComboBox("GUARD_MIN_MAX")
+ .dynamicFieldConfigAttributes(matchingAttributes).editPolicy(false).domain("test")
+ .highestVersion(0).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Decision_testGuard.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
matchingAttributes.put("guardActiveStart", "05:00");
matchingAttributes.put("guardActiveEnd", "10:00");
matchingAttributes.put("blackList", "bl1,bl2");
- StdPAPPolicy newPAPPolicy =
- new StdPAPPolicy(StdPAPPolicyParams.builder()
- .policyName("testblGuard")
- .description("test rule")
- .onapName("PDPD")
- .providerComboBox("GUARD_BL_YAML")
- .dynamicFieldConfigAttributes(matchingAttributes)
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().policyName("testblGuard").description("test rule").onapName("PDPD")
+ .providerComboBox("GUARD_BL_YAML").dynamicFieldConfigAttributes(matchingAttributes)
+ .editPolicy(false).domain("test").highestVersion(0).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Decision_testblGuard.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
Map<String, String> configAttributes = new HashMap<>();
configAttributes.put("value", "test");
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("Base")
- .policyName("test")
- .description("test rule")
- .onapName("TEST")
- .configName("config")
- .dynamicFieldConfigAttributes(configAttributes)
- .configType("OTHER")
- .configBodyData("test body")
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .riskLevel("5")
- .riskType("default")
- .guard("false")
- .ttlDate(null).build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().configPolicyType("Base").policyName("test").description("test rule")
+ .onapName("TEST").configName("config").dynamicFieldConfigAttributes(configAttributes)
+ .configType("OTHER").configBodyData("test body").editPolicy(false).domain("test")
+ .highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate(null).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
pap.service(httpServletRequest, httpServletResponse);
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
+ }
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_test.1.xml");
+ @Test
+ public void testActionPolicy() throws IOException, ServletException, SQLException {
+ setPolicyCreation();
+ httpServletRequest = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
+ Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
+ Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("API");
+ Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
+ Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Action");
+
+ CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
+ PolicyCreation.setCommonClassDao(commonClassDao);
+ ActionPolicyDict actionDict = new ActionPolicyDict();
+ actionDict.setBody("{\"test\":\"test\"}");
+ actionDict.setHeader("test122=test12:test22=test34");
+ actionDict.setType("REST");
+ actionDict.setMethod("GET");
+ actionDict.setUrl("testsomeurl.com");
+ Mockito.when(commonClassDao.getEntityItem(ActionPolicyDict.class, "attributeName", "test"))
+ .thenReturn(actionDict);
+ FunctionDefinition funcDefn = new FunctionDefinition();
+ funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:and");
+ Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "and")).thenReturn(funcDefn);
+ funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-equal");
+ Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-equal"))
+ .thenReturn(funcDefn);
+ funcDefn.setXacmlid("urn:oasis:names:tc:xacml:3.0:function:string-contains");
+ Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "string-contains"))
+ .thenReturn(funcDefn);
+ funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:integer-greater-than");
+ Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "integer-greater-than"))
+ .thenReturn(funcDefn);
+ funcDefn.setXacmlid("urn:oasis:names:tc:xacml:1.0:function:or");
+ Mockito.when(commonClassDao.getEntityItem(FunctionDefinition.class, "short_name", "or")).thenReturn(funcDefn);
+
+ Map<String, String> componentAttributes = new HashMap<>();
+ componentAttributes.put("java", "test");
+ StdPAPPolicy newPapPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().policyName("test").description("test")
+ .dynamicFieldConfigAttributes(componentAttributes)
+ .dynamicRuleAlgorithmLabels(Arrays.asList("A1", "A2", "A3", "A4", "A5", "A6", "A7"))
+ .dynamicRuleAlgorithmCombo(Arrays.asList("integer-equal", "string-contains", "integer-equal", "and",
+ "integer-greater-than", "or", "and"))
+ .dynamicRuleAlgorithmField1(Arrays.asList("cobal", "cap", "cobal", "A2", "Config", "A4", "A1"))
+ .dynamicRuleAlgorithmField2(Arrays.asList("90", "ca", "90", "A3", "45", "A5", "A6"))
+ .actionPerformer("PDP").actionAttribute("test").editPolicy(false).domain("com").highestVersion(0)
+ .build());
+ newPapPolicy.setActionBody("{\"test\":\"test\"}");
+
+ MockServletInputStream mockInput =
+ new MockServletInputStream(PolicyUtils.objectToJsonString(newPapPolicy).getBytes());
+ Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
+
+ logger.info(httpServletRequest);
+ logger.info(httpServletResponse);
+ pap.service(httpServletRequest, httpServletResponse);
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
private void setPolicyCreation() {
editorScope.setUserModifiedBy(userInfo);
Mockito.when(commonClassDao.getEntityItem(PolicyEditorScopes.class, "scopeName", "test"))
.thenReturn(editorScope);
- BRMSParamTemplate template = new BRMSParamTemplate();
+ BrmsParamTemplate template = new BrmsParamTemplate();
template.setRuleName("testPolicy");
template.setUserCreatedBy(userInfo);
- String rule = "package com.sample;\n"
- + "import com.sample.DroolsTest.Message;\n"
- + "declare Params\n"
- + "samPoll : int\n"
- + "value : String\n"
- + "end\n"
- + "///This Rule will be generated by the UI.\n"
- + "rule \"${policyName}.Create parameters structure\"\n"
- + "salience 1000 \n"
- + "when\n"
- + "then\n"
- + "Params params = new Params();\n"
- + "params.setSamPoll(76);\n"
- + "params.setValue(\"test\");\n"
- + "insertLogical(params);\n"
- + "end\n"
- + "rule \"Rule 1: Check parameter structure access from when/then\"\n"
- + "when\n"
- + "$param: Params()\n"
- + "Params($param.samPoll > 50)\n"
- + "then\n"
- + "System.out.println(\"Firing rule 1\");\n"
- + "System.out.println($param);\n"
- + "end\n";
+ String rule = "package com.sample;\n" + "import com.sample.DroolsTest.Message;\n" + "declare Params\n"
+ + "samPoll : int\n" + "value : String\n" + "end\n" + "///This Rule will be generated by the UI.\n"
+ + "rule \"${policyName}.Create parameters structure\"\n" + "salience 1000 \n" + "when\n" + "then\n"
+ + "Params params = new Params();\n" + "params.setSamPoll(76);\n" + "params.setValue(\"test\");\n"
+ + "insertLogical(params);\n" + "end\n"
+ + "rule \"Rule 1: Check parameter structure access from when/then\"\n" + "when\n" + "$param: Params()\n"
+ + "Params($param.samPoll > 50)\n" + "then\n" + "System.out.println(\"Firing rule 1\");\n"
+ + "System.out.println($param);\n" + "end\n";
template.setRule(rule);
- Mockito.when(commonClassDao.getEntityItem(BRMSParamTemplate.class, "ruleName", "testPolicy"))
+ Mockito.when(commonClassDao.getEntityItem(BrmsParamTemplate.class, "ruleName", "testPolicy"))
.thenReturn(template);
-
}
@Test
public void testClosedLoopCreateDictionary() throws IOException, SQLException, ServletException {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
- // Check VSCLAction.
+ // Check VSCLAction.
String json = "{\"dictionaryFields\": {\"vsclaction\": \"testRestAPI\",\"description\": \"testing create\"}}";
dictionaryTestSetup(false, "VSCLAction", json);
// set DBDao
ClosedLoopDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check VNFType
+ // Check VnfType
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
dictionaryTestSetup(false, "VNFType", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check PEPOptions
+ // Check PepOptions
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"pepName\":\"testRestAPI\",\"description\":\"testing create\"," +
- "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\"," +
- "\"number\":\"test\"}]}}";
- dictionaryTestSetup(false, "PEPOptions", json);
+ json = "{\"dictionaryFields\":{\"pepName\":\"testRestAPI\",\"description\":\"testing create\","
+ + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
+ + "\"number\":\"test\"}]}}";
+ dictionaryTestSetup(false, "PepOptions", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Varbind
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"varbindName\":\"testRestAPI\",\"varbindDescription\":\"testing\"," +
- "\"varbindOID\":\"test\"}}";
+ json = "{\"dictionaryFields\":{\"varbindName\":\"testRestAPI\",\"varbindDescription\":\"testing\","
+ + "\"varbindOID\":\"test\"}}";
dictionaryTestSetup(false, "Varbind", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Service
dictionaryTestSetup(false, "Service", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Site
dictionaryTestSetup(false, "Site", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
}
@Test
public void testFirewallCreateDictionary() throws IOException, SQLException, ServletException {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
- // Check SecurityZone.
+ // Check SecurityZone.
String json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"testing\"}}";
dictionaryTestSetup(false, "SecurityZone", json);
// set DBDao
FirewallDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Action List
dictionaryTestSetup(false, "ActionList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check Protocol List.
+ // Check Protocol List.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
dictionaryTestSetup(false, "ProtocolList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check Zone.
+ // Check Zone.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
dictionaryTestSetup(false, "Zone", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check PrefixList.
+ // Check PrefixList.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"prefixListName\":\"testRestAPI\",\"prefixListValue\":\"127.0.0.1\"," +
- "\"description\":\"testing\"}}";
+ json = "{\"dictionaryFields\":{\"prefixListName\":\"testRestAPI\",\"prefixListValue\":\"127.0.0.1\","
+ + "\"description\":\"testing\"}}";
dictionaryTestSetup(false, "PrefixList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check AddressGroup.
+ // Check AddressGroup.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"groupName\":\"testRestAPIgroup\",\"description\":\"testing\"," +
- "\"attributes\":[{\"option\":\"testRestAPI\"}, {\"option\":\"testRestAPI\"}]}}";
+ json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIgroup\",\"description\":\"testing\","
+ + "\"attributes\":[{\"option\":\"testRestAPI\"}, {\"option\":\"testRestAPI\"}]}}";
dictionaryTestSetup(false, "AddressGroup", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check ServiceGroup.
+ // Check ServiceGroup.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"groupName\":\"testRestAPIServiceGroup\"," +
- "\"attributes\":[{\"option\":\"testRestAPIservice\"}]}}";
+ json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIServiceGroup\","
+ + "\"attributes\":[{\"option\":\"testRestAPIservice\"}]}}";
dictionaryTestSetup(false, "ServiceGroup", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check ServiceList.
+ // Check ServiceList.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"serviceName\":\"testRestAPIservice\",\"serviceDescription\":\"test\"," +
- "\"servicePorts\":\"8888\",\"transportProtocols\":[{\"option\":\"testRestAPI\"}," +
- "{\"option\":\"testRestAPI1\"}],\"appProtocols\":[{\"option\":\"testRestAPI\"}," +
- "{\"option\":\"testRestAPI1\"}]}}";
+ json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPIservice\",\"serviceDescription\":\"test\","
+ + "\"servicePorts\":\"8888\",\"transportProtocols\":[{\"option\":\"testRestAPI\"},"
+ + "{\"option\":\"testRestAPI1\"}],\"appProtocols\":[{\"option\":\"testRestAPI\"},"
+ + "{\"option\":\"testRestAPI1\"}]}}";
dictionaryTestSetup(false, "ServiceList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check TermList.
+ // Check TermList.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"termName\":\"testRestAPIRule\",\"termDescription\":\"testing\"," +
- "\"fromZoneDatas\":[{\"option\":\"testRestAPI\"}]," +
- "\"toZoneDatas\":[{\"option\":\"testRestAPI1\"}]," +
- "\"sourceListDatas\":[{\"option\":\"Group_testportal\"}]," +
- "\"destinationListDatas\":[{\"option\":\"testRestAPI\"}]," +
- "\"sourceServiceDatas\":[{\"option\":\"testRestAPIservice\"}," +
- "{\"option\":\"testRestAPIservice1\"}]," +
- "\"destinationServiceDatas\":[{\"option\":\"testRestAPIservice1\"}," +
- "{\"option\":\"testportalservice2\"}],\"actionListDatas\":[{\"option\":\"testRestAPI\"}]}}";
+ json = "{\"dictionaryFields\":{\"termName\":\"testRestAPIRule\",\"termDescription\":\"testing\","
+ + "\"fromZoneDatas\":[{\"option\":\"testRestAPI\"}],"
+ + "\"toZoneDatas\":[{\"option\":\"testRestAPI1\"}],"
+ + "\"sourceListDatas\":[{\"option\":\"Group_testportal\"}],"
+ + "\"destinationListDatas\":[{\"option\":\"testRestAPI\"}],"
+ + "\"sourceServiceDatas\":[{\"option\":\"testRestAPIservice\"},"
+ + "{\"option\":\"testRestAPIservice1\"}],"
+ + "\"destinationServiceDatas\":[{\"option\":\"testRestAPIservice1\"},"
+ + "{\"option\":\"testportalservice2\"}],\"actionListDatas\":[{\"option\":\"testRestAPI\"}]}}";
dictionaryTestSetup(false, "TermList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
}
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
String json =
- "{\"dictionaryFields\": {\"onapName\": \"testMMRestAPI1\",\"description\": \"testing update response " +
- "message\"}}";
+ "{\"dictionaryFields\": {\"onapName\": \"testMMRestAPI1\",\"description\": \"testing update response "
+ + "message\"}}";
dictionaryTestSetup(false, "OnapName", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\": {\"xacmlId\": \"testMMRestAPI1\",\"datatypeBean\": {\"shortName\": " +
- "\"string\"}, \"description\": \"testing update\",\"priority\": \"High\"," +
- "\"userDataTypeValues\": [{\"attributeValues\": \"testAttr\"}, {\"attributeValues\": " +
- "\"testAttr2\"}, {\"attributeValues\": \"testAttr3\"}]}}";
+ json = "{\"dictionaryFields\": {\"xacmlId\": \"testMMRestAPI1\",\"datatypeBean\": {\"shortName\": "
+ + "\"string\"}, \"description\": \"testing update\",\"priority\": \"High\","
+ + "\"userDataTypeValues\": [{\"attributeValues\": \"testAttr\"}, {\"attributeValues\": "
+ + "\"testAttr2\"}, {\"attributeValues\": \"testAttr3\"}]}}";
dictionaryTestSetup(false, "Attribute", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
// Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
-
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"attributeName\":\"TestMMrestAPI1\",\"type\":\"REST\",\"url\":\"testsomeurl" +
- ".com\",\"method\":\"GET\",\"description\":\"test create\",\"body\":\"Testing Create\"," +
- "\"headers\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\"," +
- "\"number\":\"test\"}]}}";
+ json = "{\"dictionaryFields\":{\"attributeName\":\"TestMMrestAPI1\",\"type\":\"REST\",\"url\":\"testsomeurl"
+ + ".com\",\"method\":\"GET\",\"description\":\"test create\",\"body\":\"Testing Create\","
+ + "\"headers\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
+ + "\"number\":\"test\"}]}}";
dictionaryTestSetup(false, "Action", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"scopeName\":\"testMMRestAPI1\",\"description\":\"test\"," +
- "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\"," +
- "\"number\":\"test\"}]}}";
+ json = "{\"dictionaryFields\":{\"scopeName\":\"testMMRestAPI1\",\"description\":\"test\","
+ + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
+ + "\"number\":\"test\"}]}}";
dictionaryTestSetup(false, "DescriptiveScope", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"message\":\"test\"," +
- "\"riskType\":\"testMMrestAPI1\"}}";
+ json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"message\":\"test\","
+ + "\"riskType\":\"testMMrestAPI1\"}}";
dictionaryTestSetup(false, "SafePolicyWarning", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
String json =
- "{\"dictionaryFields\":{\"xacmlId\":\"testMMRestAPI1\",\"datatypeBean\":{\"shortName\":\"string\"}," +
- "\"description\":\"test\",\"priority\":\"High\"}}";
+ "{\"dictionaryFields\":{\"xacmlId\":\"testMMRestAPI1\",\"datatypeBean\":{\"shortName\":\"string\"},"
+ + "\"description\":\"test\",\"priority\":\"High\"}}";
dictionaryTestSetup(false, "Settings", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"bbid\":\"BB1\",\"workstep\":\"1\",\"treatments\":\"Manual Handling,Abort," +
- "Retry\"}}";
+ json = "{\"dictionaryFields\":{\"bbid\":\"BB1\",\"workstep\":\"1\",\"treatments\":\"Manual Handling,Abort,"
+ + "Retry\"}}";
dictionaryTestSetup(false, "RainyDayTreatments", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"groupName\":\"testMMrestAPI1\",\"description\":\"testing\"}," +
- "\"groupPolicyScopeListData1\":{\"resource\":\"ANY\",\"type\":\"ANY\",\"service\":\"ANY\"," +
- "\"closedloop\":\"ANY\"}}";
+ json = "{\"dictionaryFields\":{\"groupName\":\"testMMrestAPI1\",\"description\":\"testing\"},"
+ + "\"groupPolicyScopeListData1\":{\"resource\":\"ANY\",\"type\":\"ANY\",\"service\":\"ANY\","
+ + "\"closedloop\":\"ANY\"}}";
dictionaryTestSetup(false, "GroupPolicyScopeList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
MockServletInputStream mockInput = new MockServletInputStream(json.getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
Mockito.when(httpServletRequest.getReader()).thenReturn(new BufferedReader(new InputStreamReader(mockInput)));
- // set DBDao
- setDBDao();
}
public void setDBDao() throws SQLException {
@Test
public void getDictionary() throws ServletException, IOException {
- String[] dictionarys = new String[]{"Attribute", "OnapName", "Action", "BRMSParamTemplate", "VSCLAction"
- , "VNFType", "PEPOptions", "Varbind", "Service", "Site", "Settings", "RainyDayTreatments",
- "DescriptiveScope", "ActionList", "ProtocolList", "Zone", "SecurityZone",
- "PrefixList", "AddressGroup", "ServiceGroup", "ServiceList", "TermList",
- "MicroServiceLocation", "MicroServiceConfigName", "DCAEUUID", "MicroServiceModels",
- "PolicyScopeService", "PolicyScopeResource", "PolicyScopeType", "PolicyScopeClosedLoop",
- "GroupPolicyScopeList", "RiskType", "SafePolicyWarning", "MicroServiceDictionary"};
+ String[] dictionarys = new String[] {"Attribute", "OnapName", "Action", "BRMSParamTemplate", "VSCLAction",
+ "VNFType", "PepOptions", "Varbind", "Service", "Site", "Settings", "RainyDayTreatments",
+ "DescriptiveScope", "ActionList", "ProtocolList", "Zone", "SecurityZone", "PrefixList", "AddressGroup",
+ "ServiceGroup", "ServiceList", "TermList", "MicroServiceLocation", "MicroServiceConfigName", "DCAEUUID",
+ "MicroServiceModels", "PolicyScopeService", "PolicyScopeResource", "PolicyScopeType",
+ "PolicyScopeClosedLoop", "GroupPolicyScopeList", "RiskType", "SafePolicyWarning",
+ "MicroServiceDictionary"};
for (String dictionary : dictionarys) {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = new MockHttpServletResponse();
try {
Mockito.when(httpServletResponse.getOutputStream()).thenReturn(mockOutput);
} catch (IOException e) {
- fail();
+ fail(e.getMessage());
}
try {
pap.service(httpServletRequest, httpServletResponse);
assertTrue(true);
} catch (Exception e) {
- fail();
+ fail(e.getMessage());
}
}
- @After
- public void destroy() {
+ @AfterClass
+ public static void destroy() {
if (sessionFactory != null) {
sessionFactory.close();
}
Code Review / policy / engine.git / blobdiff