ONAP-REST/src/test/java/org/onap/policy/rest/util/PolicyValidationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2019 Nordix Foundation.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.rest.util;
  23
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertNotSame;
  27 import static org.junit.Assert.assertNull;
  28
  29 import java.io.IOException;
  30 import java.text.SimpleDateFormat;
  31 import java.util.ArrayList;
  32 import java.util.Date;
  33 import java.util.LinkedHashMap;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.UUID;
  37
  38 import org.junit.After;
  39 import org.junit.Before;
  40 import org.junit.Test;
  41 import org.onap.policy.api.PolicyConfigType;
  42 import org.onap.policy.api.PolicyParameters;
  43 import org.onap.policy.common.utils.resources.TextFileUtils;
  44 import org.onap.policy.rest.adapter.ClosedLoopFaultTrapDatas;
  45 import org.onap.policy.rest.adapter.PolicyRestAdapter;
  46
  47 public class PolicyValidationTest {
  48
  49     @Before
  50     public void setUp() throws Exception {
  51     }
  52
  53     @After
  54     public void tearDown() throws Exception {
  55     }
  56
  57     @Test
  58     public void microServicePolicyTests() throws Exception {
  59         PolicyParameters policyParameters = new PolicyParameters();
  60
  61         policyParameters.setPolicyConfigType(PolicyConfigType.MicroService);
  62         policyParameters.setPolicyName("Test.junitPolicy");
  63         policyParameters.setPolicyDescription("This is a sample Micro Service policy Create example");
  64         policyParameters.setOnapName("DCAE");
  65         policyParameters.setPriority("1");
  66         String msJsonString = TextFileUtils.getTextFileAsString("src/test/resources/policies/MicroServicePolicy.json");
  67         policyParameters.setConfigBody(msJsonString);
  68         policyParameters.setRequestID(UUID.randomUUID());
  69         SimpleDateFormat dateformat3 = new SimpleDateFormat("dd/MM/yyyy");
  70         Date date = dateformat3.parse("15/10/2016");
  71         policyParameters.setTtlDate(date);
  72         policyParameters.setGuard(true);
  73         policyParameters.setRiskLevel("5");
  74         policyParameters.setRiskType("TEST");
  75         policyParameters.setRequestID(UUID.randomUUID());
  76
  77         PolicyValidationRequestWrapper wrapper = new PolicyValidationRequestWrapper();
  78         PolicyRestAdapter policyData = wrapper.populateRequestParameters(policyParameters);
  79         PolicyValidation validation = new PolicyValidation();
  80         String responseString = validation.validatePolicy(policyData).toString();
  81
  82         assertNotSame("success", responseString);
  83
  84         new PolicyValidation(null);
  85         assertNull(PolicyValidation.getCommonClassDao());
  86
  87         policyData.setConfigPolicyType("ClosedLoop_Fault");
  88         responseString = validation.validatePolicy(policyData).toString();
  89         assertThat(responseString).doesNotContain("success");
  90
  91         policyData.setConfigPolicyType("ClosedLoop_PM");
  92         responseString = validation.validatePolicy(policyData).toString();
  93         assertThat(responseString).doesNotContain("success");
  94
  95         policyData.setConfigPolicyType("Enforcer Config");
  96         responseString = validation.validatePolicy(policyData).toString();
  97         assertThat(responseString).doesNotContain("success");
  98
  99         policyData.setConfigPolicyType("Optimization");
 100         responseString = validation.validatePolicy(policyData).toString();
 101         assertThat(responseString).doesNotContain("success");
 102
 103         policyData.setConfigPolicyType("Strange");
 104         responseString = validation.validatePolicy(policyData).toString();
 105         assertThat(responseString).doesNotContain("success");
 106     }
 107
 108     @Test
 109     public final void testEmailValidation() {
 110         PolicyValidation validation = new PolicyValidation();
 111         String result = validation.emailValidation("testemail@test.com", "SUCCESS");
 112         assertEquals("success", result);
 113     }
 114
 115     @Test
 116     public void testPolicyHeadingValidation() throws IOException {
 117         PolicyValidation validation = new PolicyValidation();
 118         PolicyRestAdapter policyData = new PolicyRestAdapter();
 119
 120         String responseString = validation.validatePolicy(policyData).toString();
 121         assertThat(responseString).contains("PolicyName Should not be empty");
 122
 123         policyData.setPolicyName("%%%~~~%%%");
 124         responseString = validation.validatePolicy(policyData).toString();
 125         assertThat(responseString).contains("The Value in Required Field will allow only '{0-9}, {a-z}, {A-Z}");
 126
 127         policyData.setPolicyName("ALegalPolicyName");
 128         policyData.setPolicyDescription("@CreatedBy:");
 129         responseString = validation.validatePolicy(policyData).toString();
 130         assertThat(responseString)
 131                         .contains("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:");
 132         policyData.setPolicyDescription("@CreatedBy:");
 133
 134         policyData.setPolicyDescription("A Legal Description");
 135         responseString = validation.validatePolicy(policyData).toString();
 136         assertThat(responseString)
 137                         .doesNotContain("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:");
 138     }
 139
 140     @Test
 141     public void testPolicyAttributeValidation() throws IOException {
 142         PolicyValidation validation = new PolicyValidation();
 143         PolicyRestAdapter policyData = new PolicyRestAdapter();
 144         policyData.setPolicyName("ALegalPolicyName");
 145         policyData.setPolicyDescription("A Valid Description");
 146
 147         String responseString = validation.validatePolicy(policyData).toString();
 148         assertEquals("success", responseString);
 149
 150         policyData.setApiflag("API");
 151         responseString = validation.validatePolicy(policyData).toString();
 152         assertEquals("success", responseString);
 153
 154         policyData.setApiflag("NOTAPI");
 155         responseString = validation.validatePolicy(policyData).toString();
 156         assertEquals("success", responseString);
 157
 158         List<Object> attributes = new ArrayList<>();
 159         policyData.setAttributes(attributes);
 160         responseString = validation.validatePolicy(policyData).toString();
 161         assertEquals("success", responseString);
 162
 163         attributes.add(new String("hello"));
 164         responseString = validation.validatePolicy(policyData).toString();
 165         assertEquals("success", responseString);
 166         attributes.clear();
 167
 168         Map<String, String> mapAttribute = new LinkedHashMap<>();
 169         attributes.add(mapAttribute);
 170         responseString = validation.validatePolicy(policyData).toString();
 171         assertThat(responseString).contains("Component Attributes</b>:<i> has one missing Component Attribute value");
 172
 173         mapAttribute.put("key", "value");
 174         responseString = validation.validatePolicy(policyData).toString();
 175         assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
 176                         responseString);
 177
 178         mapAttribute.put("key", "");
 179         responseString = validation.validatePolicy(policyData).toString();
 180         assertEquals("<b>Attributes or Component Attributes</b>:<i>null : value has spaces or invalid characters</i>"
 181                         + "<br><b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
 182                         responseString);
 183         mapAttribute.clear();
 184
 185         responseString = validation.validatePolicy(policyData).toString();
 186         mapAttribute.put("hello", "aaa");
 187         responseString = validation.validatePolicy(policyData).toString();
 188         assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute key</i><br>"
 189                         + "<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
 190                         responseString);
 191
 192         policyData.setPolicyType("Config");
 193         responseString = validation.validatePolicy(policyData).toString();
 194         assertEquals("<b>RiskType</b>: Risk Type Should not be Empty</i><br>"
 195                         + "<b>RiskLevel</b>: Risk Level Should not be Empty</i><br>"
 196                         + "<b>Guard</b>: Guard Value Should not be Empty</i><br>", responseString);
 197
 198         policyData.setConfigPolicyType("Base");
 199         responseString = validation.validatePolicy(policyData).toString();
 200         assertThat(responseString).contains("has one missing Attribute key");
 201
 202         policyData.setConfigPolicyType("BRMS_Param");
 203         responseString = validation.validatePolicy(policyData).toString();
 204         assertThat(responseString).contains("has one missing Attribute key");
 205
 206         policyData.setConfigPolicyType("BRMS_Raw");
 207         responseString = validation.validatePolicy(policyData).toString();
 208         assertThat(responseString).contains("has one missing Attribute key");
 209
 210         policyData.setConfigPolicyType(null);
 211         responseString = validation.validatePolicy(policyData).toString();
 212         assertThat(responseString).contains("Risk Level Should not be Empty");
 213
 214         mapAttribute.clear();
 215         mapAttribute.put("value", "thevalue");
 216         responseString = validation.validatePolicy(policyData).toString();
 217         assertThat(responseString).contains("Risk Level Should not be Empty");
 218
 219         mapAttribute.put("value", "$$$%%%%");
 220         responseString = validation.validatePolicy(policyData).toString();
 221         assertThat(responseString).contains("Risk Level Should not be Empty");
 222
 223         policyData.setConfigPolicyType("Base");
 224         responseString = validation.validatePolicy(policyData).toString();
 225         assertThat(responseString).contains("value has spaces or invalid characters");
 226
 227         policyData.setConfigPolicyType("BRMS_Param");
 228         responseString = validation.validatePolicy(policyData).toString();
 229         assertThat(responseString).contains("value has spaces or invalid characters");
 230
 231         policyData.setConfigPolicyType("BRMS_Raw");
 232         responseString = validation.validatePolicy(policyData).toString();
 233         assertThat(responseString).contains("value has spaces or invalid characters");
 234
 235         policyData.setConfigPolicyType(null);
 236         policyData.setPolicyType(null);
 237         responseString = validation.validatePolicy(policyData).toString();
 238         assertThat(responseString).contains("value has spaces or invalid characters");
 239     }
 240
 241     @Test
 242     public void testPolicySettingsValidation() throws IOException {
 243         PolicyValidation validation = new PolicyValidation();
 244         PolicyRestAdapter policyData = new PolicyRestAdapter();
 245         policyData.setPolicyName("ALegalPolicyName");
 246         policyData.setPolicyDescription("A Valid Description");
 247
 248         String responseString = validation.validatePolicy(policyData).toString();
 249         assertEquals("success", responseString);
 250
 251         policyData.setApiflag("API");
 252         responseString = validation.validatePolicy(policyData).toString();
 253         assertEquals("success", responseString);
 254
 255         policyData.setApiflag("NOTAPI");
 256         responseString = validation.validatePolicy(policyData).toString();
 257         assertEquals("success", responseString);
 258
 259         List<Object> settings = new ArrayList<>();
 260         policyData.setSettings(settings);
 261         responseString = validation.validatePolicy(policyData).toString();
 262         assertEquals("success", responseString);
 263
 264         settings.add("hello");
 265         responseString = validation.validatePolicy(policyData).toString();
 266         assertEquals("success", responseString);
 267         settings.clear();
 268
 269         Map<String, String> mapSetting = new LinkedHashMap<>();
 270         settings.add(mapSetting);
 271         responseString = validation.validatePolicy(policyData).toString();
 272         assertThat(responseString).contains("Settings Attributes</b>:<i> has one missing Attribute key");
 273
 274         mapSetting.put("key", "value");
 275         responseString = validation.validatePolicy(policyData).toString();
 276         assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString);
 277
 278         mapSetting.put("key", "");
 279         responseString = validation.validatePolicy(policyData).toString();
 280         assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString);
 281         mapSetting.clear();
 282
 283         mapSetting.put("value", "thevalue");
 284         responseString = validation.validatePolicy(policyData).toString();
 285         assertThat(responseString).contains("has one missing Attribute key");
 286
 287         mapSetting.put("value", "$$$%%%");
 288         responseString = validation.validatePolicy(policyData).toString();
 289         assertThat(responseString).contains("value has spaces or invalid characters");
 290     }
 291
 292     @Test
 293     public void testPolicyRuleAlgorithmsValidation() throws IOException {
 294         PolicyValidation validation = new PolicyValidation();
 295         PolicyRestAdapter policyData = new PolicyRestAdapter();
 296         policyData.setPolicyName("ALegalPolicyName");
 297         policyData.setPolicyDescription("A Valid Description");
 298
 299         String responseString = validation.validatePolicy(policyData).toString();
 300         assertEquals("success", responseString);
 301
 302         policyData.setApiflag("API");
 303         responseString = validation.validatePolicy(policyData).toString();
 304         assertEquals("success", responseString);
 305
 306         policyData.setApiflag("NOTAPI");
 307         responseString = validation.validatePolicy(policyData).toString();
 308         assertEquals("success", responseString);
 309
 310         List<Object> ruleAlgorithmschoices = new ArrayList<>();
 311         policyData.setRuleAlgorithmschoices(ruleAlgorithmschoices);
 312         responseString = validation.validatePolicy(policyData).toString();
 313         assertEquals("success", responseString);
 314
 315         ruleAlgorithmschoices.add("hello");
 316         responseString = validation.validatePolicy(policyData).toString();
 317         assertEquals("success", responseString);
 318         ruleAlgorithmschoices.clear();
 319
 320         Map<String, String> mapChoice = new LinkedHashMap<>();
 321         ruleAlgorithmschoices.add(mapChoice);
 322         assertNull(validation.validatePolicy(policyData));
 323
 324         mapChoice.clear();
 325         mapChoice.put("id", "TheID");
 326         responseString = validation.validatePolicy(policyData).toString();
 327         assertThat(responseString).contains("Field 1 value is not selected");
 328
 329         mapChoice.put("dynamicRuleAlgorithmField1", "Field1");
 330         responseString = validation.validatePolicy(policyData).toString();
 331         assertThat(responseString).contains("Field 2 value is not selected");
 332
 333         mapChoice.put("dynamicRuleAlgorithmCombo", "Combo");
 334         responseString = validation.validatePolicy(policyData).toString();
 335         assertThat(responseString).contains("Field 3 value is empty");
 336
 337         mapChoice.put("dynamicRuleAlgorithmField2", "Field2");
 338         responseString = validation.validatePolicy(policyData).toString();
 339         assertEquals("success", responseString);
 340
 341         mapChoice.put("dynamicRuleAlgorithmField2", "%%%$$$");
 342         responseString = validation.validatePolicy(policyData).toString();
 343         assertThat(responseString).contains("Field 3 value has special characters");
 344     }
 345
 346     @Test
 347     public void testPolicyConfigBaseValidation() throws IOException {
 348         PolicyValidation validation = new PolicyValidation();
 349         PolicyRestAdapter policyData = new PolicyRestAdapter();
 350         policyData.setPolicyName("ALegalPolicyName");
 351         policyData.setPolicyDescription("A Valid Description");
 352
 353         String responseString = validation.validatePolicy(policyData).toString();
 354         assertEquals("success", responseString);
 355
 356         policyData.setApiflag("API");
 357         responseString = validation.validatePolicy(policyData).toString();
 358         assertEquals("success", responseString);
 359
 360         policyData.setPolicyType("Config");
 361         policyData.setConfigPolicyType("Base");
 362         responseString = validation.validatePolicy(policyData).toString();
 363         assertThat(responseString).contains("Onap Name Should not be empty");
 364
 365         policyData.setOnapName("%%%$$$$");
 366         responseString = validation.validatePolicy(policyData).toString();
 367         assertThat(responseString).contains("<b>OnapName</b>:<i>The Value in Required Field");
 368
 369         policyData.setOnapName("AValidOnapName");
 370         responseString = validation.validatePolicy(policyData).toString();
 371         assertThat(responseString).contains("Risk Level Should not be Empty");
 372
 373         policyData.setRiskType("%%%$$$$");
 374         responseString = validation.validatePolicy(policyData).toString();
 375         assertThat(responseString).contains("<b>RiskType</b>:<i>The Value in Required Field");
 376
 377         policyData.setRiskType("AValidRiskType");
 378         responseString = validation.validatePolicy(policyData).toString();
 379         assertThat(responseString).contains("Risk Level Should not be Empty");
 380
 381         policyData.setRiskLevel("%%%$$$$");
 382         responseString = validation.validatePolicy(policyData).toString();
 383         assertThat(responseString).contains("<b>RiskLevel</b>:<i>The Value in Required Field");
 384
 385         policyData.setRiskLevel("AValidRiskLevel");
 386         responseString = validation.validatePolicy(policyData).toString();
 387         assertThat(responseString).contains("Guard Value Should not be Empty");
 388
 389         policyData.setGuard("%%%$$$$");
 390         responseString = validation.validatePolicy(policyData).toString();
 391         assertThat(responseString).contains("<b>Guard</b>:<i>The Value in Required Field");
 392
 393         policyData.setGuard("AValidGuard");
 394         responseString = validation.validatePolicy(policyData).toString();
 395         assertThat(responseString).contains("Config Name Should not be Empty");
 396
 397         policyData.setConfigName("%%%$$$$");
 398         responseString = validation.validatePolicy(policyData).toString();
 399         assertThat(responseString).contains("ConfigName:The Value in Required Field");
 400
 401         policyData.setConfigName("AValidConfigName");
 402         responseString = validation.validatePolicy(policyData).toString();
 403         assertThat(responseString).contains("Config Type Should not be Empty");
 404
 405         policyData.setConfigType("%%%$$$$");
 406         responseString = validation.validatePolicy(policyData).toString();
 407         assertThat(responseString).contains("ConfigType:The Value in Required Field");
 408
 409         policyData.setConfigType("AValidConfigType");
 410         responseString = validation.validatePolicy(policyData).toString();
 411         assertThat(responseString).contains("Config Body Should not be Empty");
 412
 413         policyData.setConfigBodyData("");
 414         responseString = validation.validatePolicy(policyData).toString();
 415         assertThat(responseString).contains("Config Body Should not be Empty");
 416
 417         policyData.setConfigBodyData("%%%$$$$");
 418         responseString = validation.validatePolicy(policyData).toString();
 419         assertEquals("success@#", responseString);
 420
 421         policyData.setConfigType(null);
 422         policyData.setConfigBodyData("ValidConfigBodyData");
 423         responseString = validation.validatePolicy(policyData).toString();
 424         assertThat(responseString).contains("Config Type Should not be Empty");
 425
 426         policyData.setConfigType("JSON");
 427         policyData.setConfigBodyData("{");
 428         responseString = validation.validatePolicy(policyData).toString();
 429         assertThat(responseString).contains("Config Body: JSON Content is not valid");
 430
 431         policyData.setConfigBodyData("ValidConfigBodyData");
 432         responseString = validation.validatePolicy(policyData).toString();
 433         assertEquals("success@#", responseString);
 434
 435         policyData.setConfigType("XML");
 436         policyData.setConfigBodyData("{");
 437         responseString = validation.validatePolicy(policyData).toString();
 438         assertThat(responseString).contains("Config Body: XML Content data is not valid");
 439
 440         policyData.setConfigBodyData("<tag>value</tag>");
 441         responseString = validation.validatePolicy(policyData).toString();
 442         assertEquals("success@#", responseString);
 443
 444         policyData.setConfigType("PROPERTIES");
 445         policyData.setConfigBodyData("{");
 446         responseString = validation.validatePolicy(policyData).toString();
 447         assertThat(responseString).contains("Config Body: Property data is not valid");
 448
 449         policyData.setConfigBodyData("propertyName=PropertyValue");
 450         responseString = validation.validatePolicy(policyData).toString();
 451         assertEquals("success@#", responseString);
 452     }
 453
 454     @Test
 455     public void testPolicyConfigFirewallValidation() throws IOException {
 456         PolicyValidation validation = new PolicyValidation();
 457         PolicyRestAdapter policyData = new PolicyRestAdapter();
 458         policyData.setPolicyName("ALegalPolicyName");
 459         policyData.setPolicyDescription("A Valid Description");
 460
 461         String responseString = validation.validatePolicy(policyData).toString();
 462         assertEquals("success", responseString);
 463
 464         policyData.setApiflag("API");
 465         responseString = validation.validatePolicy(policyData).toString();
 466         assertEquals("success", responseString);
 467
 468         // Invalid values tested in config base test
 469         policyData.setOnapName("AValidOnapName");
 470         policyData.setRiskType("AValidRiskType");
 471         policyData.setRiskLevel("AValidRiskLevel");
 472         policyData.setGuard("AValidGuard");
 473         assertEquals("success", responseString);
 474
 475         policyData.setPolicyType("Config");
 476         policyData.setConfigPolicyType("Firewall Config");
 477         responseString = validation.validatePolicy(policyData).toString();
 478         assertThat(responseString).contains("Config Name is required");
 479
 480         policyData.setConfigName("");
 481         responseString = validation.validatePolicy(policyData).toString();
 482         assertThat(responseString).contains("Config Name is required");
 483
 484         policyData.setConfigName("%%%$$$$");
 485         responseString = validation.validatePolicy(policyData).toString();
 486         assertThat(responseString).contains("<b>ConfigName</b>:<i>The Value in Required Field");
 487
 488         policyData.setConfigName("AValidConfigName");
 489         responseString = validation.validatePolicy(policyData).toString();
 490         assertThat(responseString).contains("Security Zone is required");
 491
 492         policyData.setSecurityZone("");
 493         responseString = validation.validatePolicy(policyData).toString();
 494         assertThat(responseString).contains("Security Zone is required");
 495
 496         policyData.setSecurityZone("AValidSeurityZone");
 497         responseString = validation.validatePolicy(policyData).toString();
 498         assertEquals("success@#", responseString);
 499     }
 500
 501     @Test
 502     public void testPolicyConfigBRMSValidation() throws IOException {
 503         PolicyValidation validation = new PolicyValidation();
 504         PolicyRestAdapter policyData = new PolicyRestAdapter();
 505         policyData.setPolicyName("ALegalPolicyName");
 506         policyData.setPolicyDescription("A Valid Description");
 507
 508         String responseString = validation.validatePolicy(policyData).toString();
 509         assertEquals("success", responseString);
 510
 511         policyData.setApiflag("API");
 512         responseString = validation.validatePolicy(policyData).toString();
 513         assertEquals("success", responseString);
 514
 515         // Invalid values tested in config base test
 516         policyData.setOnapName("AValidOnapName");
 517         policyData.setRiskType("AValidRiskType");
 518         policyData.setRiskLevel("AValidRiskLevel");
 519         policyData.setGuard("AValidGuard");
 520         assertEquals("success", responseString);
 521
 522         policyData.setPolicyType("Config");
 523         policyData.setConfigPolicyType("BRMS_Param");
 524         responseString = validation.validatePolicy(policyData).toString();
 525         assertThat(responseString).contains("BRMS Template is required");
 526
 527         policyData.setRuleName("");
 528         responseString = validation.validatePolicy(policyData).toString();
 529         assertThat(responseString).contains("BRMS Template is required");
 530
 531         policyData.setRuleName("AValidRuleName");
 532         responseString = validation.validatePolicy(policyData).toString();
 533         assertEquals("success@#", responseString);
 534         policyData.setRuleName(null);
 535
 536         policyData.setConfigPolicyType("BRMS_Raw");
 537         responseString = validation.validatePolicy(policyData).toString();
 538         assertThat(responseString).contains("Raw Rule is required");
 539
 540         policyData.setConfigBodyData("");
 541         responseString = validation.validatePolicy(policyData).toString();
 542         assertThat(responseString).contains("Raw Rule is required");
 543
 544         policyData.setConfigBodyData("InvalidConfigBodyData");
 545         responseString = validation.validatePolicy(policyData).toString();
 546         assertThat(responseString).contains("expecting one of the following tokens");
 547
 548         policyData.setConfigBodyData("import org.onap.policy.test.DummyTestSomething;");
 549         responseString = validation.validatePolicy(policyData).toString();
 550         assertEquals("success@#", responseString);
 551     }
 552
 553     @Test
 554     public void testPolicyConfigCloseLoopPmValidation() throws IOException {
 555         PolicyValidation validation = new PolicyValidation();
 556         PolicyRestAdapter policyData = new PolicyRestAdapter();
 557         policyData.setPolicyName("ALegalPolicyName");
 558         policyData.setPolicyDescription("A Valid Description");
 559
 560         String responseString = validation.validatePolicy(policyData).toString();
 561         assertEquals("success", responseString);
 562
 563         policyData.setApiflag("API");
 564         responseString = validation.validatePolicy(policyData).toString();
 565         assertEquals("success", responseString);
 566
 567         // Invalid values tested in config base test
 568         policyData.setOnapName("AValidOnapName");
 569         policyData.setRiskType("AValidRiskType");
 570         policyData.setRiskLevel("AValidRiskLevel");
 571         policyData.setGuard("AValidGuard");
 572         assertEquals("success", responseString);
 573
 574         policyData.setPolicyType("Config");
 575         policyData.setConfigPolicyType("ClosedLoop_PM");
 576         responseString = validation.validatePolicy(policyData).toString();
 577         assertThat(responseString).contains("ServiceType PolicyName is required");
 578
 579         Map<String, String> serviceTypePolicyName = null;
 580         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 581         responseString = validation.validatePolicy(policyData).toString();
 582         assertThat(responseString).contains("ServiceType PolicyName is required");
 583
 584         serviceTypePolicyName = new LinkedHashMap<>();
 585         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 586         responseString = validation.validatePolicy(policyData).toString();
 587         assertThat(responseString).contains("ServiceType PolicyName is required");
 588
 589         serviceTypePolicyName.put("AKey", "AValue");
 590         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 591         responseString = validation.validatePolicy(policyData).toString();
 592         assertThat(responseString).contains("ServiceType PolicyName is required");
 593         serviceTypePolicyName.clear();
 594
 595         serviceTypePolicyName.put("serviceTypePolicyName", "");
 596         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 597         responseString = validation.validatePolicy(policyData).toString();
 598         assertThat(responseString).contains("ServiceType PolicyName is required");
 599
 600         serviceTypePolicyName.put("serviceTypePolicyName", "AValidserviceTypePolicyName");
 601         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 602         responseString = validation.validatePolicy(policyData).toString();
 603         assertThat(responseString).contains("Select at least one D2");
 604
 605         policyData.setJsonBody("");
 606         assertNull(validation.validatePolicy(policyData));
 607
 608         policyData.setJsonBody("InvalidConfigBodyData");
 609         assertNull(validation.validatePolicy(policyData));
 610
 611         policyData.setJsonBody("{}");
 612         responseString = validation.validatePolicy(policyData).toString();
 613         assertThat(responseString).contains("Select at least one D2");
 614
 615         policyData.setJsonBody("{\"gamma\": false}");
 616         responseString = validation.validatePolicy(policyData).toString();
 617         assertThat(responseString).contains("Select at least one D2");
 618
 619         policyData.setJsonBody("{\"gamma\": true}");
 620         responseString = validation.validatePolicy(policyData).toString();
 621         assertEquals("success@#", responseString);
 622
 623         policyData.setJsonBody("{\"mcr\": false}");
 624         responseString = validation.validatePolicy(policyData).toString();
 625         assertThat(responseString).contains("Select at least one D2");
 626
 627         policyData.setJsonBody("{\"mcr\": true}");
 628         responseString = validation.validatePolicy(policyData).toString();
 629         assertEquals("success@#", responseString);
 630
 631         policyData.setJsonBody("{\"trinity\": false}");
 632         responseString = validation.validatePolicy(policyData).toString();
 633         assertThat(responseString).contains("Select at least one D2");
 634
 635         policyData.setJsonBody("{\"trinity\": true}");
 636         responseString = validation.validatePolicy(policyData).toString();
 637         assertEquals("success@#", responseString);
 638
 639         policyData.setJsonBody("{\"vDNS\": false}");
 640         responseString = validation.validatePolicy(policyData).toString();
 641         assertThat(responseString).contains("Select at least one D2");
 642
 643         policyData.setJsonBody("{\"vDNS\": true}");
 644         responseString = validation.validatePolicy(policyData).toString();
 645         assertEquals("success@#", responseString);
 646
 647         policyData.setJsonBody("{\"vUSP\": false}");
 648         responseString = validation.validatePolicy(policyData).toString();
 649         assertThat(responseString).contains("Select at least one D2");
 650
 651         policyData.setJsonBody("{\"vUSP\": true}");
 652         responseString = validation.validatePolicy(policyData).toString();
 653         assertEquals("success@#", responseString);
 654
 655         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
 656         responseString = validation.validatePolicy(policyData).toString();
 657         assertEquals("success@#", responseString);
 658
 659         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}");
 660         responseString = validation.validatePolicy(policyData).toString();
 661         assertThat(responseString).contains("Email Address is not Valid");
 662
 663         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"%%%$$$\"}");
 664         responseString = validation.validatePolicy(policyData).toString();
 665         assertThat(responseString).contains("Email Address is not Valid");
 666
 667         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}");
 668         responseString = validation.validatePolicy(policyData).toString();
 669         assertEquals("success@#", responseString);
 670
 671         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": null}");
 672         responseString = validation.validatePolicy(policyData).toString();
 673         assertEquals("success@#", responseString);
 674
 675         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"\"}");
 676         responseString = validation.validatePolicy(policyData).toString();
 677         assertEquals("success@#", responseString);
 678
 679         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"$$$%%%\"}");
 680         responseString = validation.validatePolicy(policyData).toString();
 681         assertThat(responseString).contains("The Value in Required Field");
 682
 683         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"AValidGeoLink\"}");
 684         responseString = validation.validatePolicy(policyData).toString();
 685         assertEquals("success@#", responseString);
 686
 687         policyData.setJsonBody("{\"trinity\": true, \"attributes\": null}");
 688         responseString = validation.validatePolicy(policyData).toString();
 689         assertEquals("success@#", responseString);
 690
 691         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {}}");
 692         responseString = validation.validatePolicy(policyData).toString();
 693         assertEquals("success@#", responseString);
 694
 695         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"av0\"}}");
 696         responseString = validation.validatePolicy(policyData).toString();
 697         assertEquals("success@#", responseString);
 698
 699         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"$$$%%%\"}}");
 700         responseString = validation.validatePolicy(policyData).toString();
 701         assertThat(responseString).contains("value has spaces or invalid characters");
 702
 703         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"Message\":\"$$$%%%\"}}");
 704         responseString = validation.validatePolicy(policyData).toString();
 705         assertEquals("success@#", responseString);
 706     }
 707
 708     @Test
 709     public void testPolicyConfigCloseLoopFaultValidation() throws IOException {
 710         PolicyValidation validation = new PolicyValidation();
 711         PolicyRestAdapter policyData = new PolicyRestAdapter();
 712         policyData.setPolicyName("ALegalPolicyName");
 713         policyData.setPolicyDescription("A Valid Description");
 714
 715         String responseString = validation.validatePolicy(policyData).toString();
 716         assertEquals("success", responseString);
 717
 718         policyData.setApiflag("API");
 719         responseString = validation.validatePolicy(policyData).toString();
 720         assertEquals("success", responseString);
 721
 722         // Invalid values tested in config base test
 723         policyData.setOnapName("AValidOnapName");
 724         policyData.setRiskType("AValidRiskType");
 725         policyData.setRiskLevel("AValidRiskLevel");
 726         policyData.setGuard("AValidGuard");
 727         assertEquals("success", responseString);
 728
 729         policyData.setPolicyType("Config");
 730         policyData.setConfigPolicyType("ClosedLoop_Fault");
 731         responseString = validation.validatePolicy(policyData).toString();
 732         assertThat(responseString).contains("Select at least one D2");
 733
 734         policyData.setJsonBody("");
 735         assertNull(validation.validatePolicy(policyData));
 736
 737         policyData.setJsonBody("InvalidConfigBodyData");
 738         assertNull(validation.validatePolicy(policyData));
 739
 740         policyData.setJsonBody("{}");
 741         responseString = validation.validatePolicy(policyData).toString();
 742         assertThat(responseString).contains("There were no conditions provided in configBody json");
 743
 744         policyData.setJsonBody("{\"conditions\": null}");
 745         responseString = validation.validatePolicy(policyData).toString();
 746         assertThat(responseString).contains("There were no conditions provided in configBody json");
 747
 748         policyData.setJsonBody("{\"conditions\": \"\"}");
 749         responseString = validation.validatePolicy(policyData).toString();
 750         assertThat(responseString).contains("Select At least one Condition");
 751
 752         policyData.setJsonBody("{\"conditions\": \"AValidCondition\"}");
 753         assertNull(validation.validatePolicy(policyData));
 754
 755         policyData.setApiflag("NOAPI");
 756
 757         policyData.setJsonBody("");
 758         assertNull(validation.validatePolicy(policyData));
 759
 760         policyData.setJsonBody("InvalidConfigBodyData");
 761         assertNull(validation.validatePolicy(policyData));
 762
 763         ClosedLoopFaultTrapDatas trapDatas = new ClosedLoopFaultTrapDatas();
 764         policyData.setTrapDatas(trapDatas);
 765
 766         ClosedLoopFaultTrapDatas faultDatas = new ClosedLoopFaultTrapDatas();
 767         policyData.setFaultDatas(faultDatas);
 768
 769         policyData.setJsonBody("{}");
 770         assertThat(responseString).contains("Select At least one Condition");
 771
 772         List<Object> trap1 = new ArrayList<>();
 773         trapDatas.setTrap1(trap1);
 774         responseString = validation.validatePolicy(policyData).toString();
 775         assertThat(responseString).contains("Trigger Clear TimeOut is required");
 776
 777         policyData.setClearTimeOut("AValidClearTimeout");
 778         responseString = validation.validatePolicy(policyData).toString();
 779         assertThat(responseString).contains("Trap Max Age is required");
 780
 781         policyData.setTrapMaxAge("AValidTrapMaxAge");
 782         responseString = validation.validatePolicy(policyData).toString();
 783         assertThat(responseString).contains("Select at least one D2");
 784
 785         trapDatas.setTrap1(null);
 786         responseString = validation.validatePolicy(policyData).toString();
 787         assertThat(responseString).contains("Select at least one D2");
 788
 789         faultDatas.setTrap1(null);
 790         responseString = validation.validatePolicy(policyData).toString();
 791         assertThat(responseString).contains("Select at least one D2");
 792
 793         faultDatas.setTrap1(trap1);
 794         responseString = validation.validatePolicy(policyData).toString();
 795         assertThat(responseString).contains("Fault Clear TimeOut is required when");
 796
 797         policyData.setVerificationclearTimeOut("AValidVerificationClearTimeout");
 798         responseString = validation.validatePolicy(policyData).toString();
 799         assertThat(responseString).contains("Select at least one D2");
 800
 801         policyData.setJsonBody("{\"gamma\": false}");
 802         responseString = validation.validatePolicy(policyData).toString();
 803         assertThat(responseString).contains("Select at least one D2");
 804
 805         policyData.setJsonBody("{\"gamma\": true}");
 806         responseString = validation.validatePolicy(policyData).toString();
 807         assertThat(responseString).contains("vPRO Actions is required");
 808
 809         policyData.setJsonBody("{\"mcr\": false}");
 810         responseString = validation.validatePolicy(policyData).toString();
 811         assertThat(responseString).contains("Select at least one D2");
 812
 813         policyData.setJsonBody("{\"mcr\": true}");
 814         responseString = validation.validatePolicy(policyData).toString();
 815         assertThat(responseString).contains("vPRO Actions is required");
 816
 817         policyData.setJsonBody("{\"trinity\": false}");
 818         responseString = validation.validatePolicy(policyData).toString();
 819         assertThat(responseString).contains("Select at least one D2");
 820
 821         policyData.setJsonBody("{\"trinity\": true}");
 822         responseString = validation.validatePolicy(policyData).toString();
 823         assertThat(responseString).contains("vPRO Actions is required");
 824
 825         policyData.setJsonBody("{\"vDNS\": false}");
 826         responseString = validation.validatePolicy(policyData).toString();
 827         assertThat(responseString).contains("Select at least one D2");
 828
 829         policyData.setJsonBody("{\"vDNS\": true}");
 830         responseString = validation.validatePolicy(policyData).toString();
 831         assertThat(responseString).contains("vPRO Actions is required");
 832
 833         policyData.setJsonBody("{\"vUSP\": false}");
 834         responseString = validation.validatePolicy(policyData).toString();
 835         assertThat(responseString).contains("Select at least one D2");
 836
 837         policyData.setJsonBody("{\"vUSP\": true}");
 838         responseString = validation.validatePolicy(policyData).toString();
 839         assertThat(responseString).contains("vPRO Actions is required");
 840
 841         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
 842         responseString = validation.validatePolicy(policyData).toString();
 843         assertThat(responseString).contains("vPRO Actions is required");
 844
 845         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}");
 846         responseString = validation.validatePolicy(policyData).toString();
 847         assertThat(responseString).contains("vPRO Actions is required");
 848
 849         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"%%%$$$\"}");
 850         responseString = validation.validatePolicy(policyData).toString();
 851         assertThat(responseString).contains("Email Address is not Valid");
 852
 853         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}");
 854         responseString = validation.validatePolicy(policyData).toString();
 855         assertThat(responseString).contains("vPRO Actions is required");
 856
 857         policyData.setJsonBody("{\"trinity\": true, \"actions\": null}");
 858         responseString = validation.validatePolicy(policyData).toString();
 859         assertThat(responseString).contains("vPRO Actions is required");
 860
 861         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"\"}");
 862         responseString = validation.validatePolicy(policyData).toString();
 863         assertThat(responseString).contains("vPRO Actions is required");
 864
 865         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"$$$%%%\"}");
 866         responseString = validation.validatePolicy(policyData).toString();
 867         assertThat(responseString).contains("Policy Status is required");
 868         assertThat(responseString).contains("Vnf Type is required");
 869
 870         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\"}");
 871         responseString = validation.validatePolicy(policyData).toString();
 872         assertThat(responseString).contains("Policy Status is required");
 873
 874         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": null}");
 875         responseString = validation.validatePolicy(policyData).toString();
 876         assertThat(responseString).contains("Policy Status is required");
 877
 878         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"\"}");
 879         responseString = validation.validatePolicy(policyData).toString();
 880         assertThat(responseString).contains("Policy Status is required");
 881
 882         policyData.setJsonBody(
 883                         "{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"$$$%%%\"}");
 884         responseString = validation.validatePolicy(policyData).toString();
 885         assertThat(responseString).contains("Select At least one Condition");
 886
 887         // @formatter:off
 888         policyData.setJsonBody("{"
 889                         + "\"trinity\": true,"
 890                         + "\"actions\": \"ValidActions\","
 891                         + "\"closedLoopPolicyStatus\": \"AValidStatus\""
 892                         + "}");
 893         // @formatter:on
 894         responseString = validation.validatePolicy(policyData).toString();
 895         assertThat(responseString).contains("Select At least one Condition");
 896
 897         // @formatter:off
 898         policyData.setJsonBody("{"
 899                         + "\"trinity\": true,"
 900                         + "\"actions\": \"ValidActions\","
 901                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 902                         + "\"conditions\": null"
 903                         + "}");
 904         // @formatter:on
 905         responseString = validation.validatePolicy(policyData).toString();
 906         assertThat(responseString).contains("Select At least one Condition");
 907
 908         // @formatter:off
 909         policyData.setJsonBody("{"
 910                         + "\"trinity\": true,"
 911                         + "\"actions\": \"ValidActions\","
 912                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 913                         + "\"conditions\": \"SEND\""
 914                         + "}");
 915         // @formatter:on
 916         responseString = validation.validatePolicy(policyData).toString();
 917         assertThat(responseString).contains("Aging Window is required");
 918
 919         // @formatter:off
 920         policyData.setJsonBody("{"
 921                         + "\"trinity\": true,"
 922                         + "\"actions\": \"ValidActions\","
 923                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 924                         + "\"conditions\": \"SEND\","
 925                         + "\"geoLink\": null"
 926                         + "}");
 927         // @formatter:on
 928         responseString = validation.validatePolicy(policyData).toString();
 929         assertThat(responseString).contains("Aging Window is required");
 930
 931         // @formatter:off
 932         policyData.setJsonBody("{"
 933                         + "\"trinity\": true,"
 934                         + "\"actions\": \"ValidActions\","
 935                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 936                         + "\"conditions\": \"SEND\","
 937                         + "\"geoLink\": \"\""
 938                         + "}");
 939         // @formatter:on
 940         responseString = validation.validatePolicy(policyData).toString();
 941         assertThat(responseString).contains("Aging Window is required");
 942
 943         // @formatter:off
 944         policyData.setJsonBody("{"
 945                         + "\"trinity\": true,"
 946                         + "\"actions\": \"ValidActions\","
 947                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 948                         + "\"conditions\": \"SEND\","
 949                         + "\"geoLink\": \"%%%$$$\""
 950                         + "}");
 951         // @formatter:on
 952         responseString = validation.validatePolicy(policyData).toString();
 953         assertThat(responseString).contains("GeoLink</b>:<i>The Value in Required Field");
 954
 955         // @formatter:off
 956         policyData.setJsonBody("{"
 957                         + "\"trinity\": true,"
 958                         + "\"actions\": \"ValidActions\","
 959                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 960                         + "\"conditions\": \"SEND\","
 961                         + "\"geoLink\": \"AValidGeoLink\""
 962                         + "}");
 963         // @formatter:on
 964         responseString = validation.validatePolicy(policyData).toString();
 965         assertThat(responseString).contains("Aging Window is required");
 966
 967         // @formatter:off
 968         policyData.setJsonBody("{"
 969                         + "\"trinity\": true,"
 970                         + "\"actions\": \"ValidActions\","
 971                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 972                         + "\"conditions\": \"SEND\","
 973                         + "\"agingWindow\": -1"
 974                         + "}");
 975         // @formatter:on
 976         responseString = validation.validatePolicy(policyData).toString();
 977         assertThat(responseString).contains("Time Interval is required");
 978
 979         // @formatter:off
 980         policyData.setJsonBody("{"
 981                         + "\"trinity\": true,"
 982                         + "\"actions\": \"ValidActions\","
 983                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 984                         + "\"conditions\": \"SEND\","
 985                         + "\"agingWindow\": -1,"
 986                         + "\"timeInterval\": -1"
 987                         + "}");
 988         // @formatter:on
 989         responseString = validation.validatePolicy(policyData).toString();
 990         assertThat(responseString).contains("Number of Retries is required");
 991
 992         // @formatter:off
 993         policyData.setJsonBody("{"
 994                         + "\"trinity\": true,"
 995                         + "\"actions\": \"ValidActions\","
 996                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 997                         + "\"conditions\": \"SEND\","
 998                         + "\"agingWindow\": -1,"
 999                         + "\"timeInterval\": -1,"
1000                         + "\"retrys\": -1"
1001                         + "}");
1002         // @formatter:on
1003         responseString = validation.validatePolicy(policyData).toString();
1004         assertThat(responseString).contains("APP-C Timeout is required");
1005
1006         // @formatter:off
1007         policyData.setJsonBody("{"
1008                         + "\"trinity\": true,"
1009                         + "\"actions\": \"ValidActions\","
1010                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1011                         + "\"conditions\": \"SEND\","
1012                         + "\"agingWindow\": -1,"
1013                         + "\"timeInterval\": -1,"
1014                         + "\"retrys\": -1,"
1015                         + "\"timeOutvPRO\": -1"
1016                         + "}");
1017         // @formatter:on
1018         responseString = validation.validatePolicy(policyData).toString();
1019         assertThat(responseString).contains("TimeOutRuby is required");
1020
1021         // @formatter:off
1022         policyData.setJsonBody("{"
1023                         + "\"trinity\": true,"
1024                         + "\"actions\": \"ValidActions\","
1025                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1026                         + "\"conditions\": \"SEND\","
1027                         + "\"agingWindow\": -1,"
1028                         + "\"timeInterval\": -1,"
1029                         + "\"retrys\": -1,"
1030                         + "\"timeOutvPRO\": -1,"
1031                         + "\"timeOutRuby\": -1"
1032                         + "}");
1033         // @formatter:on
1034         responseString = validation.validatePolicy(policyData).toString();
1035         assertThat(responseString).contains("Vnf Type is required");
1036
1037         // @formatter:off
1038         policyData.setJsonBody("{"
1039                         + "\"trinity\": true,"
1040                         + "\"actions\": \"ValidActions\","
1041                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1042                         + "\"conditions\": \"SEND\","
1043                         + "\"agingWindow\": -1,"
1044                         + "\"timeInterval\": -1,"
1045                         + "\"retrys\": -1,"
1046                         + "\"timeOutvPRO\": -1,"
1047                         + "\"timeOutRuby\": -1,"
1048                         + "\"vnfType\": null"
1049                         + "}");
1050         // @formatter:on
1051         responseString = validation.validatePolicy(policyData).toString();
1052         assertThat(responseString).contains("Vnf Type is required");
1053
1054         // @formatter:off
1055         policyData.setJsonBody("{"
1056                         + "\"trinity\": true,"
1057                         + "\"actions\": \"ValidActions\","
1058                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1059                         + "\"conditions\": \"SEND\","
1060                         + "\"agingWindow\": -1,"
1061                         + "\"timeInterval\": -1,"
1062                         + "\"retrys\": -1,"
1063                         + "\"timeOutvPRO\": -1,"
1064                         + "\"timeOutRuby\": -1,"
1065                         + "\"vnfType\": \"\""
1066                         + "}");
1067         // @formatter:on
1068         responseString = validation.validatePolicy(policyData).toString();
1069         assertThat(responseString).contains("Vnf Type is required");
1070
1071         // @formatter:off
1072         policyData.setJsonBody("{"
1073                         + "\"trinity\": true,"
1074                         + "\"actions\": \"ValidActions\","
1075                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1076                         + "\"conditions\": \"SEND\","
1077                         + "\"agingWindow\": -1,"
1078                         + "\"timeInterval\": -1,"
1079                         + "\"retrys\": -1,"
1080                         + "\"timeOutvPRO\": -1,"
1081                         + "\"timeOutRuby\": -1,"
1082                         + "\"vnfType\": \"AValid VNF Type\""
1083                         + "}");
1084         // @formatter:on
1085         responseString = validation.validatePolicy(policyData).toString();
1086         assertEquals("success@#", responseString);
1087     }
1088 }