1 files changed, 1220 insertions, 14 deletions
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 6051db4c3..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
@@ -3,13 +3,14 @@
  * ONAP-REST
  * ================================================================================
  * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
  * ================================================================================
  * 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.
@@ -17,20 +18,44 @@
  * limitations under the License.
  * ============LICENSE_END=========================================================
  */
+
 package org.onap.policy.rest.util;
 
-import static org.junit.Assert.*;
+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 {
@@ -41,9 +66,7 @@ public class PolicyValidationTest {
     }
 
     @Test
-    public void microServicePolicyTests() throws Exception{
-        PolicyValidation validation = new PolicyValidation();
-        PolicyValidationRequestWrapper wrapper = new PolicyValidationRequestWrapper();
+    public void microServicePolicyTests() throws Exception {
         PolicyParameters policyParameters = new PolicyParameters();
 
         policyParameters.setPolicyConfigType(PolicyConfigType.MicroService);
@@ -51,8 +74,8 @@ 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\"}]}}";;
-        policyParameters.setConfigBody(MSjsonString);
+        String msJsonString = TextFileUtils.getTextFileAsString("src/test/resources/policies/MicroServicePolicy.json");
+        policyParameters.setConfigBody(msJsonString);
         policyParameters.setRequestID(UUID.randomUUID());
         SimpleDateFormat dateformat3 = new SimpleDateFormat("dd/MM/yyyy");
         Date date = dateformat3.parse("15/10/2016");
@@ -62,19 +85,1202 @@ public class PolicyValidationTest {
         policyParameters.setRiskType("TEST");
         policyParameters.setRequestID(UUID.randomUUID());
 
-
+        PolicyValidationRequestWrapper wrapper = new PolicyValidationRequestWrapper();
         PolicyRestAdapter policyData = wrapper.populateRequestParameters(policyParameters);
-        StringBuilder responseString = validation.validatePolicy(policyData);
+        PolicyValidation validation = new PolicyValidation();
+        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);
 
-        assertNotSame("success", responseString.toString());
+        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");
+
+        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");
+    }
 }