diff options
10 files changed, 1557 insertions, 52 deletions
diff --git a/ONAP-REST/src/main/java/org/onap/policy/rest/util/MsModelUtils.java b/ONAP-REST/src/main/java/org/onap/policy/rest/util/MsModelUtils.java index 5b596be45..b18572574 100644 --- a/ONAP-REST/src/main/java/org/onap/policy/rest/util/MsModelUtils.java +++ b/ONAP-REST/src/main/java/org/onap/policy/rest/util/MsModelUtils.java @@ -202,7 +202,6 @@ public class MsModelUtils { processXmiEpackage(file); } return classMap; - } /** diff --git a/ONAP-REST/src/main/java/org/onap/policy/rest/util/PolicyValidation.java b/ONAP-REST/src/main/java/org/onap/policy/rest/util/PolicyValidation.java index 6bab919ad..70be83208 100644 --- a/ONAP-REST/src/main/java/org/onap/policy/rest/util/PolicyValidation.java +++ b/ONAP-REST/src/main/java/org/onap/policy/rest/util/PolicyValidation.java @@ -47,6 +47,8 @@ import javax.json.JsonObject; import javax.json.JsonReader; import javax.json.JsonValue; +import lombok.Getter; + import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicySetType; import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; @@ -113,6 +115,7 @@ public class PolicyValidation { private static Map<String, String> jsonRequestMap = new HashMap<>(); private static List<String> modelRequiredFieldsList = new ArrayList<>(); + @Getter private static CommonClassDao commonClassDao; private Set<String> allReqTrueKeys = new HashSet<>(); @@ -230,7 +233,7 @@ public class PolicyValidation { // Decision Policy Attributes Validation if (!"API".equals(policyData.getApiflag()) && policyData.getSettings() != null && !policyData.getSettings().isEmpty()) { - for (Object attribute : policyData.getAttributes()) { + for (Object attribute : policyData.getSettings()) { if (attribute instanceof LinkedHashMap<?, ?>) { String value = null; if (((LinkedHashMap<?, ?>) attribute).get("key") == null) { @@ -375,15 +378,11 @@ public class PolicyValidation { valid = false; } } else if ("PROPERTIES".equals(configType)) { - if (!PolicyUtils.isPropValid(configBodyData) || "".equals(configBodyData)) { + if (!PolicyUtils.isPropValid(configBodyData)) { responseString.append( "Config Body: Property data is not valid" + HTML_ITALICS_LNBREAK); valid = false; } - } else if ("OTHER".equals(configType) && ("".equals(configBodyData))) { - responseString.append( - "Config Body: Config Body Should not be Empty" + HTML_ITALICS_LNBREAK); - valid = false; } } } else { @@ -487,7 +486,7 @@ public class PolicyValidation { } } else { responseString.append( - "<b>D2/Virtualized Services</b>:<i>Select atleast one D2/Virtualized Services" + "<b>D2/Virtualized Services</b>:<i>Select at least one D2/Virtualized Services" + HTML_ITALICS_LNBREAK); valid = false; } @@ -603,7 +602,7 @@ public class PolicyValidation { } } else { responseString.append( - "<b>D2/Virtualized Services</b>: <i>Select atleast one D2/Virtualized Services" + "<b>D2/Virtualized Services</b>: <i>Select at least one D2/Virtualized Services" + HTML_ITALICS_LNBREAK); responseString.append( "<b>vPRO Actions</b>: <i>vPRO Actions is required" + HTML_ITALICS_LNBREAK); @@ -881,7 +880,7 @@ public class PolicyValidation { } } - protected String emailValidation(String email, String response) { + private String emailValidation(String email, String response) { String res = response; if (email != null) { String validateEmail = PolicyUtils.validateEmailAddress(email.replace("\"", "")); diff --git a/ONAP-REST/src/test/java/org/onap/policy/rest/util/PolicyValidationTest.java b/ONAP-REST/src/test/java/org/onap/policy/rest/util/PolicyValidationTest.java index 47b0f49b5..d019c6370 100644 --- a/ONAP-REST/src/test/java/org/onap/policy/rest/util/PolicyValidationTest.java +++ b/ONAP-REST/src/test/java/org/onap/policy/rest/util/PolicyValidationTest.java @@ -21,21 +21,41 @@ package org.onap.policy.rest.util; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertNull; +import com.fasterxml.jackson.databind.ObjectMapper; + +import java.io.IOException; import java.text.SimpleDateFormat; +import java.util.ArrayList; import java.util.Date; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; import java.util.UUID; import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; import org.onap.policy.api.PolicyConfigType; import org.onap.policy.api.PolicyParameters; +import org.onap.policy.common.utils.resources.TextFileUtils; +import org.onap.policy.rest.adapter.ClosedLoopFaultTrapDatas; import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.MicroServiceModels; +@RunWith(MockitoJUnitRunner.class) public class PolicyValidationTest { + @Mock + private CommonClassDao commonClassDao; @Before public void setUp() throws Exception { @@ -54,19 +74,7 @@ public class PolicyValidationTest { policyParameters.setPolicyDescription("This is a sample Micro Service policy Create example"); policyParameters.setOnapName("DCAE"); policyParameters.setPriority("1"); - String msJsonString = "{\"service\":\"TOSCA_namingJenny\",\"location\":\"Test DictMSLoc\"," - + "\"uuid\":\"testDict DCAEUIID\",\"policyName\":\"testModelValidation\"," - + "\"description\":\"test\",\"configName\":\"testDict MSConfName\"," - + "\"templateVersion\":\"1607\",\"version\":\"gw12181031\",\"priority\":\"5\"," - + "\"policyScope\":\"resource=ResourcetypeVenktest1,service=ServiceName1707,type=Name1707," - + "closedLoopControlName=Retest_retest1\",\"riskType\":\"Test\",\"riskLevel\":\"3\"," - + "\"guard\":\"True\",\"content\":{\"police-instance-name\":\"testing\"," - + "\"naming-models\":[{\"naming-properties\":[{\"property-value\":\"test\"," - + "\"source-endpoint\":\"test\",\"property-name\":\"testPropertyname\"," - + "\"increment-sequence\":{\"scope\":\"VNF\",\"start-value\":\"1\",\"length\":\"3\"," - + "\"increment\":\"2\"},\"source-system\":\"TOSCA\"}],\"naming-type\":\"testNamingType\"," - + "\"naming-recipe\":\"testNamingRecipe\"}]}}"; - ; + String msJsonString = TextFileUtils.getTextFileAsString("src/test/resources/policies/MicroServicePolicy.json"); policyParameters.setConfigBody(msJsonString); policyParameters.setRequestID(UUID.randomUUID()); SimpleDateFormat dateformat3 = new SimpleDateFormat("dd/MM/yyyy"); @@ -80,17 +88,1199 @@ public class PolicyValidationTest { PolicyValidationRequestWrapper wrapper = new PolicyValidationRequestWrapper(); PolicyRestAdapter policyData = wrapper.populateRequestParameters(policyParameters); PolicyValidation validation = new PolicyValidation(); - StringBuilder responseString = validation.validatePolicy(policyData); + String responseString = validation.validatePolicy(policyData).toString(); + + assertNotSame("success", responseString); + + new PolicyValidation(null); + assertNull(PolicyValidation.getCommonClassDao()); + + policyData.setConfigPolicyType("ClosedLoop_Fault"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).doesNotContain("success"); + + policyData.setConfigPolicyType("ClosedLoop_PM"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).doesNotContain("success"); + + policyData.setConfigPolicyType("Enforcer Config"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).doesNotContain("success"); + + policyData.setConfigPolicyType("Optimization"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).doesNotContain("success"); + + policyData.setConfigPolicyType("Strange"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).doesNotContain("success"); + } + + @Test + public void testPolicyHeadingValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + + String responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("PolicyName Should not be empty"); + + policyData.setPolicyName("%%%~~~%%%"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("The Value in Required Field will allow only '{0-9}, {a-z}, {A-Z}"); + + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("@CreatedBy:"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString) + .contains("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:"); + policyData.setPolicyDescription("@CreatedBy:"); + + policyData.setPolicyDescription("A Legal Description"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString) + .doesNotContain("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:"); + } + + @Test + public void testPolicyAttributeValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("NOTAPI"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + List<Object> attributes = new ArrayList<>(); + policyData.setAttributes(attributes); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + attributes.add(new String("hello")); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + attributes.clear(); + + Map<String, String> mapAttribute = new LinkedHashMap<>(); + attributes.add(mapAttribute); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Component Attributes</b>:<i> has one missing Component Attribute value"); + + mapAttribute.put("key", "value"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>", + responseString); + + mapAttribute.put("key", ""); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("<b>Attributes or Component Attributes</b>:<i>null : value has spaces or invalid characters</i>" + + "<br><b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>", + responseString); + mapAttribute.clear(); + + responseString = validation.validatePolicy(policyData).toString(); + mapAttribute.put("hello", "aaa"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute key</i><br>" + + "<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>", + responseString); + + policyData.setPolicyType("Config"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("<b>RiskType</b>: Risk Type Should not be Empty</i><br>" + + "<b>RiskLevel</b>: Risk Level Should not be Empty</i><br>" + + "<b>Guard</b>: Guard Value Should not be Empty</i><br>", responseString); + + policyData.setConfigPolicyType("Base"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("has one missing Attribute key"); + + policyData.setConfigPolicyType("BRMS_Param"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("has one missing Attribute key"); + + policyData.setConfigPolicyType("BRMS_Raw"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("has one missing Attribute key"); + + policyData.setConfigPolicyType(null); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Risk Level Should not be Empty"); + + mapAttribute.clear(); + mapAttribute.put("value", "thevalue"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Risk Level Should not be Empty"); + + mapAttribute.put("value", "$$$%%%%"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Risk Level Should not be Empty"); + + policyData.setConfigPolicyType("Base"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("value has spaces or invalid characters"); + + policyData.setConfigPolicyType("BRMS_Param"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("value has spaces or invalid characters"); + + policyData.setConfigPolicyType("BRMS_Raw"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("value has spaces or invalid characters"); + + policyData.setConfigPolicyType(null); + policyData.setPolicyType(null); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("value has spaces or invalid characters"); + } + + @Test + public void testPolicySettingsValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("NOTAPI"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + List<Object> settings = new ArrayList<>(); + policyData.setSettings(settings); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + settings.add("hello"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + settings.clear(); + + Map<String, String> mapSetting = new LinkedHashMap<>(); + settings.add(mapSetting); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Settings Attributes</b>:<i> has one missing Attribute key"); + + mapSetting.put("key", "value"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString); + + mapSetting.put("key", ""); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString); + mapSetting.clear(); + + mapSetting.put("value", "thevalue"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("has one missing Attribute key"); + + mapSetting.put("value", "$$$%%%"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("value has spaces or invalid characters"); + } + + @Test + public void testPolicyRuleAlgorithmsValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("NOTAPI"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + List<Object> ruleAlgorithmschoices = new ArrayList<>(); + policyData.setRuleAlgorithmschoices(ruleAlgorithmschoices); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + ruleAlgorithmschoices.add("hello"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + ruleAlgorithmschoices.clear(); + + Map<String, String> mapChoice = new LinkedHashMap<>(); + ruleAlgorithmschoices.add(mapChoice); + assertNull(validation.validatePolicy(policyData)); + + mapChoice.clear(); + mapChoice.put("id", "TheID"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Field 1 value is not selected"); + + mapChoice.put("dynamicRuleAlgorithmField1", "Field1"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Field 2 value is not selected"); + + mapChoice.put("dynamicRuleAlgorithmCombo", "Combo"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Field 3 value is empty"); + + mapChoice.put("dynamicRuleAlgorithmField2", "Field2"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + mapChoice.put("dynamicRuleAlgorithmField2", "%%%$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Field 3 value has special characters"); + } + + @Test + public void testPolicyConfigBaseValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setPolicyType("Config"); + policyData.setConfigPolicyType("Base"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Onap Name Should not be empty"); + + policyData.setOnapName("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>OnapName</b>:<i>The Value in Required Field"); + + policyData.setOnapName("AValidOnapName"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Risk Level Should not be Empty"); + + policyData.setRiskType("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>RiskType</b>:<i>The Value in Required Field"); + + policyData.setRiskType("AValidRiskType"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Risk Level Should not be Empty"); + + policyData.setRiskLevel("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>RiskLevel</b>:<i>The Value in Required Field"); + + policyData.setRiskLevel("AValidRiskLevel"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Guard Value Should not be Empty"); + + policyData.setGuard("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Guard</b>:<i>The Value in Required Field"); + + policyData.setGuard("AValidGuard"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Name Should not be Empty"); + + policyData.setConfigName("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("ConfigName:The Value in Required Field"); + + policyData.setConfigName("AValidConfigName"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Type Should not be Empty"); + + policyData.setConfigType("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("ConfigType:The Value in Required Field"); + + policyData.setConfigType("AValidConfigType"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Body Should not be Empty"); + + policyData.setConfigBodyData(""); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Body Should not be Empty"); + + policyData.setConfigBodyData("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setConfigType(null); + policyData.setConfigBodyData("ValidConfigBodyData"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Type Should not be Empty"); + + policyData.setConfigType("JSON"); + policyData.setConfigBodyData("{"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Body: JSON Content is not valid"); + + policyData.setConfigBodyData("ValidConfigBodyData"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setConfigType("XML"); + policyData.setConfigBodyData("{"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Body: XML Content data is not valid"); + + policyData.setConfigBodyData("<tag>value</tag>"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setConfigType("PROPERTIES"); + policyData.setConfigBodyData("{"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Body: Property data is not valid"); + + policyData.setConfigBodyData("propertyName=PropertyValue"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + } + + @Test + public void testPolicyConfigFirewallValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + // Invalid values tested in config base test + policyData.setOnapName("AValidOnapName"); + policyData.setRiskType("AValidRiskType"); + policyData.setRiskLevel("AValidRiskLevel"); + policyData.setGuard("AValidGuard"); + assertEquals("success", responseString); + + policyData.setPolicyType("Config"); + policyData.setConfigPolicyType("Firewall Config"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Name is required"); + + policyData.setConfigName(""); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Config Name is required"); + + policyData.setConfigName("%%%$$$$"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>ConfigName</b>:<i>The Value in Required Field"); + + policyData.setConfigName("AValidConfigName"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Security Zone is required"); + + policyData.setSecurityZone(""); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Security Zone is required"); + + policyData.setSecurityZone("AValidSeurityZone"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + } + + @Test + public void testPolicyConfigBRMSValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + // Invalid values tested in config base test + policyData.setOnapName("AValidOnapName"); + policyData.setRiskType("AValidRiskType"); + policyData.setRiskLevel("AValidRiskLevel"); + policyData.setGuard("AValidGuard"); + assertEquals("success", responseString); + + policyData.setPolicyType("Config"); + policyData.setConfigPolicyType("BRMS_Param"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("BRMS Template is required"); + + policyData.setRuleName(""); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("BRMS Template is required"); + + policyData.setRuleName("AValidRuleName"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + policyData.setRuleName(null); + + policyData.setConfigPolicyType("BRMS_Raw"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Raw Rule is required"); + + policyData.setConfigBodyData(""); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Raw Rule is required"); + + policyData.setConfigBodyData("InvalidConfigBodyData"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("expecting one of the following tokens"); + + policyData.setConfigBodyData("import org.onap.policy.test.DummyTestSomething;"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + } + + @Test + public void testPolicyConfigCloseLoopPmValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + // Invalid values tested in config base test + policyData.setOnapName("AValidOnapName"); + policyData.setRiskType("AValidRiskType"); + policyData.setRiskLevel("AValidRiskLevel"); + policyData.setGuard("AValidGuard"); + assertEquals("success", responseString); + + policyData.setPolicyType("Config"); + policyData.setConfigPolicyType("ClosedLoop_PM"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("ServiceType PolicyName is required"); + + Map<String, String> serviceTypePolicyName = null; + policyData.setServiceTypePolicyName(serviceTypePolicyName); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("ServiceType PolicyName is required"); - assertNotSame("success", responseString.toString()); + serviceTypePolicyName = new LinkedHashMap<>(); + policyData.setServiceTypePolicyName(serviceTypePolicyName); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("ServiceType PolicyName is required"); + serviceTypePolicyName.put("AKey", "AValue"); + policyData.setServiceTypePolicyName(serviceTypePolicyName); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("ServiceType PolicyName is required"); + serviceTypePolicyName.clear(); + + serviceTypePolicyName.put("serviceTypePolicyName", ""); + policyData.setServiceTypePolicyName(serviceTypePolicyName); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("ServiceType PolicyName is required"); + + serviceTypePolicyName.put("serviceTypePolicyName", "AValidserviceTypePolicyName"); + policyData.setServiceTypePolicyName(serviceTypePolicyName); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody(""); + assertNull(validation.validatePolicy(policyData)); + + policyData.setJsonBody("InvalidConfigBodyData"); + assertNull(validation.validatePolicy(policyData)); + + policyData.setJsonBody("{}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"gamma\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"gamma\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"mcr\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"mcr\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"trinity\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"vDNS\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"vDNS\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"vUSP\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"vUSP\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Email Address is not Valid"); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"%%%$$$\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Email Address is not Valid"); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"geoLink\": null}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"$$$%%%\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("The Value in Required Field"); + + policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"AValidGeoLink\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"attributes\": null}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"attributes\": {}}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"av0\"}}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"$$$%%%\"}}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("value has spaces or invalid characters"); + + policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"Message\":\"$$$%%%\"}}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); } @Test - public final void testEmailValidation() { + public void testPolicyConfigCloseLoopFaultValidation() throws IOException { PolicyValidation validation = new PolicyValidation(); - String result = validation.emailValidation("testemail@test.com", "SUCCESS"); - assertEquals("success", result); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("API"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + // Invalid values tested in config base test + policyData.setOnapName("AValidOnapName"); + policyData.setRiskType("AValidRiskType"); + policyData.setRiskLevel("AValidRiskLevel"); + policyData.setGuard("AValidGuard"); + assertEquals("success", responseString); + + policyData.setPolicyType("Config"); + policyData.setConfigPolicyType("ClosedLoop_Fault"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody(""); + assertNull(validation.validatePolicy(policyData)); + + policyData.setJsonBody("InvalidConfigBodyData"); + assertNull(validation.validatePolicy(policyData)); + + policyData.setJsonBody("{}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("There were no conditions provided in configBody json"); + + policyData.setJsonBody("{\"conditions\": null}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("There were no conditions provided in configBody json"); + + policyData.setJsonBody("{\"conditions\": \"\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select At least one Condition"); + + policyData.setJsonBody("{\"conditions\": \"AValidCondition\"}"); + assertNull(validation.validatePolicy(policyData)); + + policyData.setApiflag("NOAPI"); + + policyData.setJsonBody(""); + assertNull(validation.validatePolicy(policyData)); + + policyData.setJsonBody("InvalidConfigBodyData"); + assertNull(validation.validatePolicy(policyData)); + + ClosedLoopFaultTrapDatas trapDatas = new ClosedLoopFaultTrapDatas(); + policyData.setTrapDatas(trapDatas); + + ClosedLoopFaultTrapDatas faultDatas = new ClosedLoopFaultTrapDatas(); + policyData.setFaultDatas(faultDatas); + + policyData.setJsonBody("{}"); + assertThat(responseString).contains("Select At least one Condition"); + + List<Object> trap1 = new ArrayList<>(); + trapDatas.setTrap1(trap1); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Trigger Clear TimeOut is required"); + + policyData.setClearTimeOut("AValidClearTimeout"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Trap Max Age is required"); + + policyData.setTrapMaxAge("AValidTrapMaxAge"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + trapDatas.setTrap1(null); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + faultDatas.setTrap1(null); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + faultDatas.setTrap1(trap1); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Fault Clear TimeOut is required when"); + + policyData.setVerificationclearTimeOut("AValidVerificationClearTimeout"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"gamma\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"gamma\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"mcr\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"mcr\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"trinity\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"trinity\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"vDNS\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"vDNS\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"vUSP\": false}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select at least one D2"); + + policyData.setJsonBody("{\"vUSP\": true}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"%%%$$$\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Email Address is not Valid"); + + policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"trinity\": true, \"actions\": null}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"trinity\": true, \"actions\": \"\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("vPRO Actions is required"); + + policyData.setJsonBody("{\"trinity\": true, \"actions\": \"$$$%%%\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Policy Status is required"); + assertThat(responseString).contains("Vnf Type is required"); + + policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Policy Status is required"); + + policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": null}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Policy Status is required"); + + policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Policy Status is required"); + + policyData.setJsonBody( + "{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"$$$%%%\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select At least one Condition"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select At least one Condition"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": null" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Select At least one Condition"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Aging Window is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"geoLink\": null" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Aging Window is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"geoLink\": \"\"" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Aging Window is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"geoLink\": \"%%%$$$\"" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("GeoLink</b>:<i>The Value in Required Field"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"geoLink\": \"AValidGeoLink\"" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Aging Window is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Time Interval is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1," + + "\"timeInterval\": -1" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Number of Retries is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1," + + "\"timeInterval\": -1," + + "\"retrys\": -1" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("APP-C Timeout is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1," + + "\"timeInterval\": -1," + + "\"retrys\": -1," + + "\"timeOutvPRO\": -1" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("TimeOutRuby is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1," + + "\"timeInterval\": -1," + + "\"retrys\": -1," + + "\"timeOutvPRO\": -1," + + "\"timeOutRuby\": -1" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Vnf Type is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1," + + "\"timeInterval\": -1," + + "\"retrys\": -1," + + "\"timeOutvPRO\": -1," + + "\"timeOutRuby\": -1," + + "\"vnfType\": null" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Vnf Type is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1," + + "\"timeInterval\": -1," + + "\"retrys\": -1," + + "\"timeOutvPRO\": -1," + + "\"timeOutRuby\": -1," + + "\"vnfType\": \"\"" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Vnf Type is required"); + + // @formatter:off + policyData.setJsonBody("{" + + "\"trinity\": true," + + "\"actions\": \"ValidActions\"," + + "\"closedLoopPolicyStatus\": \"AValidStatus\"," + + "\"conditions\": \"SEND\"," + + "\"agingWindow\": -1," + + "\"timeInterval\": -1," + + "\"retrys\": -1," + + "\"timeOutvPRO\": -1," + + "\"timeOutRuby\": -1," + + "\"vnfType\": \"AValid VNF Type\"" + + "}"); + // @formatter:on + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); } + @Test + public void testPolicyConfigMicroServiceValidation() throws IOException { + PolicyValidation validation = new PolicyValidation(commonClassDao); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + policyData.setPolicyName("ALegalPolicyName"); + policyData.setPolicyDescription("A Valid Description"); + + String responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + policyData.setApiflag("NOAPI"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success", responseString); + + // Invalid values tested in config base test + policyData.setOnapName("AValidOnapName"); + policyData.setRiskType("AValidRiskType"); + policyData.setRiskLevel("AValidRiskLevel"); + policyData.setGuard("AValidGuard"); + assertEquals("success", responseString); + + policyData.setPolicyType("Config"); + policyData.setConfigPolicyType("Micro Service"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Micro Service Model is required"); + + policyData.setServiceType(""); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Micro Service Model is required"); + + policyData.setServiceType("ServiceType"); + assertNull(validation.validatePolicy(policyData)); + + policyData.setPolicyJSON(""); + assertNull(validation.validatePolicy(policyData)); + + String msJsonContentString0 = TextFileUtils + .getTextFileAsString("src/test/resources/policies/MicroServicePolicyContent0.json"); + policyData.setPolicyJSON(new ObjectMapper().readTree(msJsonContentString0)); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Micro Service Version is required"); + + String msJsonContentString1 = TextFileUtils + .getTextFileAsString("src/test/resources/policies/MicroServicePolicyContent1.json"); + policyData.setPolicyJSON(new ObjectMapper().readTree(msJsonContentString1)); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Micro Service Version is required"); + + policyData.setServiceType("ServiceType-vServiceVersion"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("The model name, ServiceType of version, ServiceVersion was not found"); + + policyData.setServiceType("ServiceType"); + policyData.setRuleProvider("MicroService_Model"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).doesNotContain("Priority is required"); + + policyData.setVersion("ServiceVersion"); + Mockito.when(commonClassDao.getDataById(MicroServiceModels.class, "modelName:version", + "ServiceType:ServiceVersion")).thenReturn(null); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("The model name, ServiceType of version, ServiceVersion was not found"); + + List<Object> msModelsList = new ArrayList<>(); + MicroServiceModels msModels = new MicroServiceModels(); + msModelsList.add(msModels); + Mockito.when(commonClassDao.getDataById(MicroServiceModels.class, "modelName:version", + "ServiceType:ServiceVersion")).thenReturn(msModelsList); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setAnnotation("SomeAnntation"); + assertNull(validation.validatePolicy(policyData)); + + msModels.setAnnotation("annotation0Key=annotation0Value"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setAnnotation("annotation0Key=range::10-100"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("annotation0Key is required for the MicroService model"); + + msModels.setAnnotation("police-instance-name=range::10-100"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Model Range:police-instance-name must be between 10 - 100"); + + msModels.setAnnotation("police-instance-range=range::12-100"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Model Range:police-instance-range must be between 12 - 100"); + + msModels.setAnnotation("police-instance-range=range::0-10"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("Model Range:police-instance-range must be between 0 - 10"); + + msModels.setAnnotation("police-instance-range=range::10-100"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setAnnotation(null); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setRuleProvider("Not_MicroService_Model"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> location is required for this model"); + + policyData.setLocation("AValidLocation"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> configName is required for this model"); + + policyData.setConfigName("AValidConfigname"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> uuid is required for this model"); + + policyData.setUuid("AValidUUID"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> policyScope is required for this model"); + + policyData.setPolicyScope("AValidPolicyScope"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Priority</b>:<i> Priority is required"); + + policyData.setPriority("AValidPriority"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + policyData.setApiflag("API"); + assertNull(validation.validatePolicy(policyData)); + + msModels.setSubAttributes("{}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setSubAttributes("{\"subAttrName0\": \"subAttrValue0\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setSubAttributes("{\"subAttrName0\": 10}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setSubAttributes("{\"subAttrName0\": {}}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setSubAttributes("{\"subAttrName0\": []}"); + responseString = validation.validatePolicy(policyData).toString(); + assertEquals("success@#", responseString); + + msModels.setSubAttributes("{\"subAttrName0\": \"subAttrValue0-required-true\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setSubAttributes("{\"subAttrName0\": \":subAttrValue0-required-true\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setSubAttributes("{\"subAttrName0\": \"UnknownType:subAttrValue0-required-true\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setSubAttributes("{\"subAttrName0\": \"string:subAttrValue0-required-true\"}"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setRefAttributes("refAttrName0="); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setRefAttributes("refAttrName0=refAttrValue0"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setRefAttributes("refAttrName0=refAttrValue0-required-true"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setAttributes(""); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setAttributes("modelAttrName0=modelAttrValue0"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required"); + + msModels.setRefAttributes("refAttrName0=refAttrValue0-required-true,"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).contains("refAttrName0 is required"); + + msModels.setRefAttributes("police-instance-range=refAttrValue0-required-true,"); + responseString = validation.validatePolicy(policyData).toString(); + assertThat(responseString).doesNotContain("police-instance-range is required"); + } } diff --git a/ONAP-REST/src/test/resources/policies/MicroServicePolicy.json b/ONAP-REST/src/test/resources/policies/MicroServicePolicy.json new file mode 100644 index 000000000..b9c06e536 --- /dev/null +++ b/ONAP-REST/src/test/resources/policies/MicroServicePolicy.json @@ -0,0 +1,38 @@ +{ + "service": "TOSCA_namingJenny", + "location": "Test DictMSLoc", + "uuid": "testDict DCAEUIID", + "policyName": "testModelValidation", + "description": "test", + "configName": "testDict MSConfName", + "templateVersion": "1607", + "version": "gw12181031", + "priority": "5", + "policyScope": "resource=ResourcetypeVenktest1,service=ServiceName1707,type=Name1707,closedLoopControlName=Retest_retest1", + "riskType": "Test", + "riskLevel": "3", + "guard": "True", + "content": { + "police-instance-name": "testing", + "naming-models": [ + { + "naming-properties": [ + { + "property-value": "test", + "source-endpoint": "test", + "property-name": "testPropertyname", + "increment-sequence": { + "scope": "VNF", + "start-value": "1", + "length": "3", + "increment": "2" + }, + "source-system": "TOSCA" + } + ], + "naming-type": "testNamingType", + "naming-recipe": "testNamingRecipe" + } + ] + } +} diff --git a/ONAP-REST/src/test/resources/policies/MicroServicePolicyContent0.json b/ONAP-REST/src/test/resources/policies/MicroServicePolicyContent0.json new file mode 100644 index 000000000..f06d2f21c --- /dev/null +++ b/ONAP-REST/src/test/resources/policies/MicroServicePolicyContent0.json @@ -0,0 +1,23 @@ +{ + "police-instance-name": "content0", + "naming-models": [ + { + "naming-properties": [ + { + "property-value": "test", + "source-endpoint": "test", + "property-name": "testPropertyname", + "increment-sequence": { + "scope": "VNF", + "start-value": "1", + "length": "3", + "increment": "2" + }, + "source-system": "TOSCA" + } + ], + "naming-type": "testNamingType", + "naming-recipe": "testNamingRecipe" + } + ] +} diff --git a/ONAP-REST/src/test/resources/policies/MicroServicePolicyContent1.json b/ONAP-REST/src/test/resources/policies/MicroServicePolicyContent1.json new file mode 100644 index 000000000..dac78c0bb --- /dev/null +++ b/ONAP-REST/src/test/resources/policies/MicroServicePolicyContent1.json @@ -0,0 +1,27 @@ +{ + "police-instance-name": "content1", + "police-instance-range": "11", + "naming-models": [ + { + "naming-properties": [ + { + "property-value": "test", + "source-endpoint": "test", + "property-name": "testPropertyname", + "increment-sequence": { + "scope": "VNF", + "start-value": "1", + "length": "3", + "increment": "2" + }, + "source-system": "TOSCA" + } + ], + "naming-type": "testNamingType", + "naming-recipe": "testNamingRecipe" + } + ], + "some-container": { + "container-name": "container-value" + } +} diff --git a/POLICY-SDK-APP/src/test/java/org/onap/policy/daoImp/CommonClassDaoImplTest.java b/POLICY-SDK-APP/src/test/java/org/onap/policy/daoImp/CommonClassDaoImplTest.java index 3453f6acc..dbe49c7c3 100644 --- a/POLICY-SDK-APP/src/test/java/org/onap/policy/daoImp/CommonClassDaoImplTest.java +++ b/POLICY-SDK-APP/src/test/java/org/onap/policy/daoImp/CommonClassDaoImplTest.java @@ -24,23 +24,29 @@ package org.onap.policy.daoImp; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.when; import java.io.File; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Properties; - import javax.script.SimpleBindings; - import org.apache.tomcat.dbcp.dbcp2.BasicDataSource; import org.h2.tools.Server; +import org.hibernate.Criteria; +import org.hibernate.Session; import org.hibernate.SessionFactory; +import org.hibernate.Transaction; import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.mockito.Mockito; import org.onap.policy.common.logging.flexlogger.FlexLogger; import org.onap.policy.common.logging.flexlogger.Logger; import org.onap.policy.conf.HibernateSession; @@ -136,7 +142,7 @@ public class CommonClassDaoImplTest { onapName.setModifiedDate(new Date()); commonClassDao.save(onapName); - List<Object> list = commonClassDao.getData(OnapName.class); + List<?> list = commonClassDao.getData(OnapName.class); assertTrue(list.size() == 1); logger.debug(list.size()); logger.debug(list.get(0)); @@ -158,7 +164,7 @@ public class CommonClassDaoImplTest { userinfo.setUserName(loginIdUserName); commonClassDao.save(userinfo); - List<Object> dataCur = commonClassDao.getDataByQuery("from UserInfo", new SimpleBindings()); + List<?> dataCur = commonClassDao.getDataByQuery("from UserInfo", new SimpleBindings()); assertEquals(1, dataCur.size()); UserInfo cur = (UserInfo) dataCur.get(0); @@ -190,7 +196,7 @@ public class CommonClassDaoImplTest { pe.setCreatedBy("Test"); commonClassDao.save(pe); - List<Object> dataCur = commonClassDao.getDataByQuery("from PolicyEntity", new SimpleBindings()); + List<?> dataCur = commonClassDao.getDataByQuery("from PolicyEntity", new SimpleBindings()); assertTrue(1 == dataCur.size()); assertTrue(dataCur.get(0) instanceof PolicyEntity); @@ -231,7 +237,7 @@ public class CommonClassDaoImplTest { String query = "From PolicyVersion where policy_name like :scope and id > 0"; SimpleBindings params = new SimpleBindings(); params.put("scope", scope); - List<Object> dataCur = commonClassDao.getDataByQuery(query, params); + List<?> dataCur = commonClassDao.getDataByQuery(query, params); assertTrue(1 == dataCur.size()); assertEquals(pv, dataCur.get(0)); @@ -268,7 +274,7 @@ public class CommonClassDaoImplTest { String query = "from WatchPolicyNotificationTable where policyName like:policyFileName"; SimpleBindings params = new SimpleBindings(); params.put("policyFileName", policyFileName); - List<Object> dataCur = commonClassDao.getDataByQuery(query, params); + List<?> dataCur = commonClassDao.getDataByQuery(query, params); // Assertions assertTrue(dataCur.size() == 1); @@ -306,7 +312,7 @@ public class CommonClassDaoImplTest { String[] splitDbCheckName = dbCheckName.split(":"); params.put("splitDBCheckName1", splitDbCheckName[1] + "%"); params.put("splitDBCheckName0", splitDbCheckName[0]); - List<Object> dataCur = commonClassDao.getDataByQuery(query, params); + List<?> dataCur = commonClassDao.getDataByQuery(query, params); // Assertions assertTrue(dataCur.size() == 1); @@ -337,7 +343,7 @@ public class CommonClassDaoImplTest { SimpleBindings params = new SimpleBindings(); params.put("finalName", finalName); params.put("userId", userId); - List<Object> dataCur = commonClassDao.getDataByQuery(query, params); + List<?> dataCur = commonClassDao.getDataByQuery(query, params); // Assertions assertTrue(dataCur.size() == 1); @@ -379,7 +385,7 @@ public class CommonClassDaoImplTest { SimpleBindings params = new SimpleBindings(); params.put("finalName", finalName); params.put("userId", userId); - List<Object> dataCur = commonClassDao.getDataByQuery(query, params); + List<?> dataCur = commonClassDao.getDataByQuery(query, params); // Assertions assertTrue(dataCur.size() <= 1); @@ -402,7 +408,7 @@ public class CommonClassDaoImplTest { userInfo.setUserLoginId("TestID"); userInfo.setUserName("Test"); commonClassDao.save(userInfo); - List<Object> data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test"); + List<?> data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test"); assertTrue(data.size() == 1); UserInfo userInfoUpdate = (UserInfo) data.get(0); userInfoUpdate.setUserName("Test1"); @@ -412,8 +418,7 @@ public class CommonClassDaoImplTest { UserInfo data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId:userName", "TestID:Test1"); assertTrue("TestID".equals(data2.getUserLoginId())); - List<Object> data3 = - commonClassDao.checkDuplicateEntry("TestID:Test1", "userLoginId:userName", UserInfo.class); + List<?> data3 = commonClassDao.checkDuplicateEntry("TestID:Test1", "userLoginId:userName", UserInfo.class); assertTrue(data3.size() == 1); PolicyRoles roles = new PolicyRoles(); roles.setRole("admin"); @@ -424,8 +429,8 @@ public class CommonClassDaoImplTest { assertTrue(roles1.size() == 1); List<String> multipleData = new ArrayList<>(); multipleData.add("TestID:Test1"); - List<Object> data4 = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, - "userLoginId:userName", multipleData); + List<?> data4 = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, "userLoginId:userName", + multipleData); assertTrue(data4.size() == 1); commonClassDao.delete(data2); } catch (Exception e) { @@ -456,6 +461,70 @@ public class CommonClassDaoImplTest { } } + @SuppressWarnings("unchecked") + @Test + public void testExceptions() { + SessionFactory sfMock = Mockito.mock(SessionFactory.class); + Session mockSession = Mockito.mock(Session.class); + Criteria crMock = Mockito.mock(Criteria.class); + Transaction mockTransaction = Mockito.mock(Transaction.class); + + CommonClassDaoImpl.setSessionfactory(sfMock); + + when(sfMock.openSession()).thenReturn(mockSession); + when(mockSession.createCriteria(OnapName.class)).thenReturn(crMock); + + when(crMock.list()).thenThrow(Exception.class); + when(mockSession.close()).thenThrow(Exception.class); + + when(mockSession.beginTransaction()).thenReturn(mockTransaction); + doThrow(Exception.class).when(mockTransaction).commit(); + + List<?> dataList = commonClassDao.getData(OnapName.class); + assertNull(dataList); + + List<?> dataByIdList = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test"); + assertNull(dataByIdList); + + commonClassDao.save(null); + commonClassDao.delete(null); + commonClassDao.update(null); + + List<?> dupEntryList = + commonClassDao.checkDuplicateEntry("TestID:Test", "userLoginId:userName", UserInfo.class); + assertNull(dupEntryList); + + List<PolicyRoles> userRoles = commonClassDao.getUserRoles(); + assertNull(userRoles); + + Object entityItem = commonClassDao.getEntityItem(UserInfo.class, "testColName", "testKey"); + assertNull(entityItem); + + commonClassDao.updateQuery("testQueryString"); + + List<String> dataByColumn = commonClassDao.getDataByColumn(UserInfo.class, "testColName"); + assertNull(dataByColumn); + + List<?> entityData = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, "", null); + assertNull(entityData); + } + + @Test + public void testCheckExistingGroupListforUpdate() { + Object retObj = commonClassDao.checkExistingGroupListforUpdate("testString1", "testString2"); + assertNotNull(retObj); + assertTrue(retObj instanceof List); + List<?> retList = (List<?>) retObj; + assertTrue(retList.isEmpty()); + } + + @Test + public void testEmptyMethods() { + commonClassDao.deleteAll(); + commonClassDao.updateClAlarms("TestString1", "TestString2"); + commonClassDao.updateClYaml("TestString1", "TestString2"); + } + @After public void deleteDB() { sessionFactory.close(); diff --git a/POLICY-SDK-APP/src/test/java/org/onap/policy/daoImp/SystemLogDbDaoImplTest.java b/POLICY-SDK-APP/src/test/java/org/onap/policy/daoImp/SystemLogDbDaoImplTest.java new file mode 100644 index 000000000..5675d3fc9 --- /dev/null +++ b/POLICY-SDK-APP/src/test/java/org/onap/policy/daoImp/SystemLogDbDaoImplTest.java @@ -0,0 +1,75 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP Policy Engine + * ================================================================================ + * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.daoImp; + +import static org.junit.Assert.assertNull; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.when; + +import java.util.List; +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.Transaction; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.policy.conf.HibernateSession; +import org.onap.policy.controller.PolicyController; +import org.onap.policy.rest.jpa.SystemLogDb; + +public class SystemLogDbDaoImplTest { + private static Session mockSession = Mockito.mock(Session.class); + private static SessionFactory sfMock = Mockito.mock(SessionFactory.class); + private static Transaction mockTransaction = Mockito.mock(Transaction.class); + private SystemLogDbDaoImpl sysLogImpl = new SystemLogDbDaoImpl(); + + @SuppressWarnings("unchecked") + @BeforeClass + public static void setup() { + HibernateSession.setSession(sfMock); + + when(sfMock.openSession()).thenReturn(mockSession); + when(mockSession.beginTransaction()).thenReturn(mockTransaction); + + doThrow(Exception.class).when(mockTransaction).commit(); + when(mockSession.close()).thenThrow(Exception.class); + + PolicyController.setjUnit(true); + } + + @Test + public void testGettingLoggingData() { + List<SystemLogDb> loggingData = sysLogImpl.getLoggingData(); + assertNull(loggingData); + } + + @Test + public void testGetSystemAlertData() { + List<SystemLogDb> systemAlertData = sysLogImpl.getSystemAlertData(); + assertNull(systemAlertData); + } + + @AfterClass + public static void resetjUnit() { + PolicyController.setjUnit(false); + } +} diff --git a/POLICY-SDK-APP/src/test/java/org/onap/policy/model/PDPGroupContainerTest.java b/POLICY-SDK-APP/src/test/java/org/onap/policy/model/PDPGroupContainerTest.java index 0cfba2cc1..f184bde1b 100644 --- a/POLICY-SDK-APP/src/test/java/org/onap/policy/model/PDPGroupContainerTest.java +++ b/POLICY-SDK-APP/src/test/java/org/onap/policy/model/PDPGroupContainerTest.java @@ -2,10 +2,8 @@ * ============LICENSE_START======================================================= * ONAP Policy Engine * ================================================================================ - * Copyright (C) 2018-2019 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Modifications Copyright (C) 2019 Samsung - * ================================================================================ + * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -24,9 +22,11 @@ package org.onap.policy.model; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; +import static org.mockito.Mockito.doThrow; import com.att.research.xacml.api.pap.PAPException; - +import java.awt.Checkbox; +import java.util.Set; import org.junit.Test; import org.mockito.Mockito; import org.onap.policy.rest.util.PolicyContainer.ItemSetChangeListener; @@ -35,6 +35,9 @@ import org.onap.policy.xacml.api.pap.OnapPDPGroup; import org.onap.policy.xacml.api.pap.PAPPolicyEngine; public class PDPGroupContainerTest { + private OnapPDPGroup group = Mockito.mock(OnapPDPGroup.class); + private OnapPDPGroup newGroup = Mockito.mock(OnapPDPGroup.class); + private OnapPDP pdp = Mockito.mock(OnapPDP.class); private PAPPolicyEngine engine = Mockito.mock(PAPPolicyEngine.class); private PDPGroupContainer container = new PDPGroupContainer(engine); @@ -46,13 +49,11 @@ public class PDPGroupContainerTest { container.refreshGroups(); assertEquals(container.getGroups().size(), 0); - OnapPDPGroup group = Mockito.mock(OnapPDPGroup.class); container.makeDefault(group); - OnapPDPGroup newGroup = Mockito.mock(OnapPDPGroup.class); container.removeGroup(group, newGroup); - OnapPDP pdp = Mockito.mock(OnapPDP.class); container.updatePDP(pdp); container.updateGroup(group); + container.updateGroup(group, "testUserName"); assertNull(container.getContainerPropertyIds()); assertEquals(container.getItemIds().size(), 0); assertEquals(container.getType(itemId), null); @@ -118,4 +119,50 @@ public class PDPGroupContainerTest { public void testGetItemIds() { container.getItemIds(0, 1); } -} + + @Test + public void testGetType() { + assertEquals(Boolean.class, container.getType("Default")); + assertEquals(Checkbox.class, container.getType("Selected")); + assertEquals(Set.class, container.getType("PDPs")); + assertEquals(Set.class, container.getType("Policies")); + assertEquals(Set.class, container.getType("PIP Configurations")); + assertEquals(String.class, container.getType("Id")); + assertEquals(String.class, container.getType("Name")); + assertEquals(String.class, container.getType("Description")); + assertEquals(String.class, container.getType("Status")); + } + + @Test + public void testContainerPAPExceptions() throws PAPException { + doThrow(PAPException.class).when(engine).getOnapPDPGroups(); + container.refreshGroups(); + + doThrow(PAPException.class).when(engine).setDefaultGroup(group); + container.makeDefault(group); + + doThrow(PAPException.class).when(engine).updatePDP(pdp); + container.updatePDP(pdp); + + doThrow(PAPException.class).when(engine).updateGroup(group); + container.updateGroup(group); + + doThrow(PAPException.class).when(engine).updateGroup(group, "testUserName"); + container.updateGroup(group, "testUserName"); + + doThrow(PAPException.class).when(engine).movePDP(pdp, group); + container.movePDP(pdp, group); + } + + @Test(expected = PAPException.class) + public void testContainerRemoveGroup() throws PAPException { + doThrow(PAPException.class).when(engine).removeGroup(group, newGroup); + container.removeGroup(group, newGroup); + } + + @Test(expected = PAPException.class) + public void testContainerRemovePDP() throws PAPException { + doThrow(PAPException.class).when(engine).removePDP(pdp); + container.removePDP(pdp, group); + } +}
\ No newline at end of file diff --git a/POLICY-SDK-APP/src/test/java/org/onap/policy/model/RolesTest.java b/POLICY-SDK-APP/src/test/java/org/onap/policy/model/RolesTest.java new file mode 100644 index 000000000..745579af9 --- /dev/null +++ b/POLICY-SDK-APP/src/test/java/org/onap/policy/model/RolesTest.java @@ -0,0 +1,38 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP Policy Engine + * ================================================================================ + * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.model; + +import com.openpojo.reflection.filters.FilterPackageInfo; +import com.openpojo.validation.Validator; +import com.openpojo.validation.ValidatorBuilder; +import com.openpojo.validation.test.impl.GetterTester; +import com.openpojo.validation.test.impl.SetterTester; + +import org.junit.Test; + +public class RolesTest { + + @Test + public void testRolesSettersAndGetters() { + final Validator validator = ValidatorBuilder.create().with(new SetterTester()).with(new GetterTester()).build(); + validator.validate(RolesTest.class.getPackage().getName(), new FilterPackageInfo()); + } +} |