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 com.fasterxml.jackson.databind.ObjectMapper;
  30
  31 import java.io.IOException;
  32 import java.text.SimpleDateFormat;
  33 import java.util.ArrayList;
  34 import java.util.Date;
  35 import java.util.LinkedHashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.UUID;
  39
  40 import org.junit.After;
  41 import org.junit.Before;
  42 import org.junit.Test;
  43 import org.junit.runner.RunWith;
  44 import org.mockito.Mock;
  45 import org.mockito.Mockito;
  46 import org.mockito.runners.MockitoJUnitRunner;
  47 import org.onap.policy.api.PolicyConfigType;
  48 import org.onap.policy.api.PolicyParameters;
  49 import org.onap.policy.common.utils.resources.TextFileUtils;
  50 import org.onap.policy.rest.adapter.ClosedLoopFaultTrapDatas;
  51 import org.onap.policy.rest.adapter.PolicyRestAdapter;
  52 import org.onap.policy.rest.dao.CommonClassDao;
  53 import org.onap.policy.rest.jpa.MicroServiceModels;
  54
  55 @RunWith(MockitoJUnitRunner.class)
  56 public class PolicyValidationTest {
  57     @Mock
  58     private CommonClassDao commonClassDao;
  59
  60     @Before
  61     public void setUp() throws Exception {
  62     }
  63
  64     @After
  65     public void tearDown() throws Exception {
  66     }
  67
  68     @Test
  69     public void microServicePolicyTests() throws Exception {
  70         PolicyParameters policyParameters = new PolicyParameters();
  71
  72         policyParameters.setPolicyConfigType(PolicyConfigType.MicroService);
  73         policyParameters.setPolicyName("Test.junitPolicy");
  74         policyParameters.setPolicyDescription("This is a sample Micro Service policy Create example");
  75         policyParameters.setOnapName("DCAE");
  76         policyParameters.setPriority("1");
  77         String msJsonString = TextFileUtils.getTextFileAsString("src/test/resources/policies/MicroServicePolicy.json");
  78         policyParameters.setConfigBody(msJsonString);
  79         policyParameters.setRequestID(UUID.randomUUID());
  80         SimpleDateFormat dateformat3 = new SimpleDateFormat("dd/MM/yyyy");
  81         Date date = dateformat3.parse("15/10/2016");
  82         policyParameters.setTtlDate(date);
  83         policyParameters.setGuard(true);
  84         policyParameters.setRiskLevel("5");
  85         policyParameters.setRiskType("TEST");
  86         policyParameters.setRequestID(UUID.randomUUID());
  87
  88         PolicyValidationRequestWrapper wrapper = new PolicyValidationRequestWrapper();
  89         PolicyRestAdapter policyData = wrapper.populateRequestParameters(policyParameters);
  90         PolicyValidation validation = new PolicyValidation();
  91         String responseString = validation.validatePolicy(policyData).toString();
  92
  93         assertNotSame("success", responseString);
  94
  95         new PolicyValidation(null);
  96         assertNull(PolicyValidation.getCommonClassDao());
  97
  98         policyData.setConfigPolicyType("ClosedLoop_Fault");
  99         responseString = validation.validatePolicy(policyData).toString();
 100         assertThat(responseString).doesNotContain("success");
 101
 102         policyData.setConfigPolicyType("ClosedLoop_PM");
 103         responseString = validation.validatePolicy(policyData).toString();
 104         assertThat(responseString).doesNotContain("success");
 105
 106         policyData.setConfigPolicyType("Enforcer Config");
 107         responseString = validation.validatePolicy(policyData).toString();
 108         assertThat(responseString).doesNotContain("success");
 109
 110         policyData.setConfigPolicyType("Optimization");
 111         responseString = validation.validatePolicy(policyData).toString();
 112         assertThat(responseString).doesNotContain("success");
 113
 114         policyData.setConfigPolicyType("Strange");
 115         responseString = validation.validatePolicy(policyData).toString();
 116         assertThat(responseString).doesNotContain("success");
 117     }
 118
 119     @Test
 120     public void testPolicyHeadingValidation() throws IOException {
 121         PolicyValidation validation = new PolicyValidation();
 122         PolicyRestAdapter policyData = new PolicyRestAdapter();
 123
 124         String responseString = validation.validatePolicy(policyData).toString();
 125         assertThat(responseString).contains("PolicyName Should not be empty");
 126
 127         policyData.setPolicyName("%%%~~~%%%");
 128         responseString = validation.validatePolicy(policyData).toString();
 129         assertThat(responseString).contains("The Value in Required Field will allow only '{0-9}, {a-z}, {A-Z}");
 130
 131         policyData.setPolicyName("ALegalPolicyName");
 132         policyData.setPolicyDescription("@CreatedBy:");
 133         responseString = validation.validatePolicy(policyData).toString();
 134         assertThat(responseString)
 135                         .contains("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:");
 136         policyData.setPolicyDescription("@CreatedBy:");
 137
 138         policyData.setPolicyDescription("A Legal Description");
 139         responseString = validation.validatePolicy(policyData).toString();
 140         assertThat(responseString)
 141                         .doesNotContain("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:");
 142     }
 143
 144     @Test
 145     public void testPolicyAttributeValidation() throws IOException {
 146         PolicyValidation validation = new PolicyValidation();
 147         PolicyRestAdapter policyData = new PolicyRestAdapter();
 148         policyData.setPolicyName("ALegalPolicyName");
 149         policyData.setPolicyDescription("A Valid Description");
 150
 151         String responseString = validation.validatePolicy(policyData).toString();
 152         assertEquals("success", responseString);
 153
 154         policyData.setApiflag("API");
 155         responseString = validation.validatePolicy(policyData).toString();
 156         assertEquals("success", responseString);
 157
 158         policyData.setApiflag("NOTAPI");
 159         responseString = validation.validatePolicy(policyData).toString();
 160         assertEquals("success", responseString);
 161
 162         List<Object> attributes = new ArrayList<>();
 163         policyData.setAttributes(attributes);
 164         responseString = validation.validatePolicy(policyData).toString();
 165         assertEquals("success", responseString);
 166
 167         attributes.add(new String("hello"));
 168         responseString = validation.validatePolicy(policyData).toString();
 169         assertEquals("success", responseString);
 170         attributes.clear();
 171
 172         Map<String, String> mapAttribute = new LinkedHashMap<>();
 173         attributes.add(mapAttribute);
 174         responseString = validation.validatePolicy(policyData).toString();
 175         assertThat(responseString).contains("Component Attributes</b>:<i> has one missing Component Attribute value");
 176
 177         mapAttribute.put("key", "value");
 178         responseString = validation.validatePolicy(policyData).toString();
 179         assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
 180                         responseString);
 181
 182         mapAttribute.put("key", "");
 183         responseString = validation.validatePolicy(policyData).toString();
 184         assertEquals("<b>Attributes or Component Attributes</b>:<i>null : value has spaces or invalid characters</i>"
 185                         + "<br><b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
 186                         responseString);
 187         mapAttribute.clear();
 188
 189         responseString = validation.validatePolicy(policyData).toString();
 190         mapAttribute.put("hello", "aaa");
 191         responseString = validation.validatePolicy(policyData).toString();
 192         assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute key</i><br>"
 193                         + "<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
 194                         responseString);
 195
 196         policyData.setPolicyType("Config");
 197         responseString = validation.validatePolicy(policyData).toString();
 198         assertEquals("<b>RiskType</b>: Risk Type Should not be Empty</i><br>"
 199                         + "<b>RiskLevel</b>: Risk Level Should not be Empty</i><br>"
 200                         + "<b>Guard</b>: Guard Value Should not be Empty</i><br>", responseString);
 201
 202         policyData.setConfigPolicyType("Base");
 203         responseString = validation.validatePolicy(policyData).toString();
 204         assertThat(responseString).contains("has one missing Attribute key");
 205
 206         policyData.setConfigPolicyType("BRMS_Param");
 207         responseString = validation.validatePolicy(policyData).toString();
 208         assertThat(responseString).contains("has one missing Attribute key");
 209
 210         policyData.setConfigPolicyType("BRMS_Raw");
 211         responseString = validation.validatePolicy(policyData).toString();
 212         assertThat(responseString).contains("has one missing Attribute key");
 213
 214         policyData.setConfigPolicyType(null);
 215         responseString = validation.validatePolicy(policyData).toString();
 216         assertThat(responseString).contains("Risk Level Should not be Empty");
 217
 218         mapAttribute.clear();
 219         mapAttribute.put("value", "thevalue");
 220         responseString = validation.validatePolicy(policyData).toString();
 221         assertThat(responseString).contains("Risk Level Should not be Empty");
 222
 223         mapAttribute.put("value", "$$$%%%%");
 224         responseString = validation.validatePolicy(policyData).toString();
 225         assertThat(responseString).contains("Risk Level Should not be Empty");
 226
 227         policyData.setConfigPolicyType("Base");
 228         responseString = validation.validatePolicy(policyData).toString();
 229         assertThat(responseString).contains("value has spaces or invalid characters");
 230
 231         policyData.setConfigPolicyType("BRMS_Param");
 232         responseString = validation.validatePolicy(policyData).toString();
 233         assertThat(responseString).contains("value has spaces or invalid characters");
 234
 235         policyData.setConfigPolicyType("BRMS_Raw");
 236         responseString = validation.validatePolicy(policyData).toString();
 237         assertThat(responseString).contains("value has spaces or invalid characters");
 238
 239         policyData.setConfigPolicyType(null);
 240         policyData.setPolicyType(null);
 241         responseString = validation.validatePolicy(policyData).toString();
 242         assertThat(responseString).contains("value has spaces or invalid characters");
 243     }
 244
 245     @Test
 246     public void testPolicySettingsValidation() throws IOException {
 247         PolicyValidation validation = new PolicyValidation();
 248         PolicyRestAdapter policyData = new PolicyRestAdapter();
 249         policyData.setPolicyName("ALegalPolicyName");
 250         policyData.setPolicyDescription("A Valid Description");
 251
 252         String responseString = validation.validatePolicy(policyData).toString();
 253         assertEquals("success", responseString);
 254
 255         policyData.setApiflag("API");
 256         responseString = validation.validatePolicy(policyData).toString();
 257         assertEquals("success", responseString);
 258
 259         policyData.setApiflag("NOTAPI");
 260         responseString = validation.validatePolicy(policyData).toString();
 261         assertEquals("success", responseString);
 262
 263         List<Object> settings = new ArrayList<>();
 264         policyData.setSettings(settings);
 265         responseString = validation.validatePolicy(policyData).toString();
 266         assertEquals("success", responseString);
 267
 268         settings.add("hello");
 269         responseString = validation.validatePolicy(policyData).toString();
 270         assertEquals("success", responseString);
 271         settings.clear();
 272
 273         Map<String, String> mapSetting = new LinkedHashMap<>();
 274         settings.add(mapSetting);
 275         responseString = validation.validatePolicy(policyData).toString();
 276         assertThat(responseString).contains("Settings Attributes</b>:<i> has one missing Attribute key");
 277
 278         mapSetting.put("key", "value");
 279         responseString = validation.validatePolicy(policyData).toString();
 280         assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString);
 281
 282         mapSetting.put("key", "");
 283         responseString = validation.validatePolicy(policyData).toString();
 284         assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString);
 285         mapSetting.clear();
 286
 287         mapSetting.put("value", "thevalue");
 288         responseString = validation.validatePolicy(policyData).toString();
 289         assertThat(responseString).contains("has one missing Attribute key");
 290
 291         mapSetting.put("value", "$$$%%%");
 292         responseString = validation.validatePolicy(policyData).toString();
 293         assertThat(responseString).contains("value has spaces or invalid characters");
 294     }
 295
 296     @Test
 297     public void testPolicyRuleAlgorithmsValidation() throws IOException {
 298         PolicyValidation validation = new PolicyValidation();
 299         PolicyRestAdapter policyData = new PolicyRestAdapter();
 300         policyData.setPolicyName("ALegalPolicyName");
 301         policyData.setPolicyDescription("A Valid Description");
 302
 303         String responseString = validation.validatePolicy(policyData).toString();
 304         assertEquals("success", responseString);
 305
 306         policyData.setApiflag("API");
 307         responseString = validation.validatePolicy(policyData).toString();
 308         assertEquals("success", responseString);
 309
 310         policyData.setApiflag("NOTAPI");
 311         responseString = validation.validatePolicy(policyData).toString();
 312         assertEquals("success", responseString);
 313
 314         List<Object> ruleAlgorithmschoices = new ArrayList<>();
 315         policyData.setRuleAlgorithmschoices(ruleAlgorithmschoices);
 316         responseString = validation.validatePolicy(policyData).toString();
 317         assertEquals("success", responseString);
 318
 319         ruleAlgorithmschoices.add("hello");
 320         responseString = validation.validatePolicy(policyData).toString();
 321         assertEquals("success", responseString);
 322         ruleAlgorithmschoices.clear();
 323
 324         Map<String, String> mapChoice = new LinkedHashMap<>();
 325         ruleAlgorithmschoices.add(mapChoice);
 326         assertNull(validation.validatePolicy(policyData));
 327
 328         mapChoice.clear();
 329         mapChoice.put("id", "TheID");
 330         responseString = validation.validatePolicy(policyData).toString();
 331         assertThat(responseString).contains("Field 1 value is not selected");
 332
 333         mapChoice.put("dynamicRuleAlgorithmField1", "Field1");
 334         responseString = validation.validatePolicy(policyData).toString();
 335         assertThat(responseString).contains("Field 2 value is not selected");
 336
 337         mapChoice.put("dynamicRuleAlgorithmCombo", "Combo");
 338         responseString = validation.validatePolicy(policyData).toString();
 339         assertThat(responseString).contains("Field 3 value is empty");
 340
 341         mapChoice.put("dynamicRuleAlgorithmField2", "Field2");
 342         responseString = validation.validatePolicy(policyData).toString();
 343         assertEquals("success", responseString);
 344
 345         mapChoice.put("dynamicRuleAlgorithmField2", "%%%$$$");
 346         responseString = validation.validatePolicy(policyData).toString();
 347         assertThat(responseString).contains("Field 3 value has special characters");
 348     }
 349
 350     @Test
 351     public void testPolicyConfigBaseValidation() throws IOException {
 352         PolicyValidation validation = new PolicyValidation();
 353         PolicyRestAdapter policyData = new PolicyRestAdapter();
 354         policyData.setPolicyName("ALegalPolicyName");
 355         policyData.setPolicyDescription("A Valid Description");
 356
 357         String responseString = validation.validatePolicy(policyData).toString();
 358         assertEquals("success", responseString);
 359
 360         policyData.setApiflag("API");
 361         responseString = validation.validatePolicy(policyData).toString();
 362         assertEquals("success", responseString);
 363
 364         policyData.setPolicyType("Config");
 365         policyData.setConfigPolicyType("Base");
 366         responseString = validation.validatePolicy(policyData).toString();
 367         assertThat(responseString).contains("Onap Name Should not be empty");
 368
 369         policyData.setOnapName("%%%$$$$");
 370         responseString = validation.validatePolicy(policyData).toString();
 371         assertThat(responseString).contains("<b>OnapName</b>:<i>The Value in Required Field");
 372
 373         policyData.setOnapName("AValidOnapName");
 374         responseString = validation.validatePolicy(policyData).toString();
 375         assertThat(responseString).contains("Risk Level Should not be Empty");
 376
 377         policyData.setRiskType("%%%$$$$");
 378         responseString = validation.validatePolicy(policyData).toString();
 379         assertThat(responseString).contains("<b>RiskType</b>:<i>The Value in Required Field");
 380
 381         policyData.setRiskType("AValidRiskType");
 382         responseString = validation.validatePolicy(policyData).toString();
 383         assertThat(responseString).contains("Risk Level Should not be Empty");
 384
 385         policyData.setRiskLevel("%%%$$$$");
 386         responseString = validation.validatePolicy(policyData).toString();
 387         assertThat(responseString).contains("<b>RiskLevel</b>:<i>The Value in Required Field");
 388
 389         policyData.setRiskLevel("AValidRiskLevel");
 390         responseString = validation.validatePolicy(policyData).toString();
 391         assertThat(responseString).contains("Guard Value Should not be Empty");
 392
 393         policyData.setGuard("%%%$$$$");
 394         responseString = validation.validatePolicy(policyData).toString();
 395         assertThat(responseString).contains("<b>Guard</b>:<i>The Value in Required Field");
 396
 397         policyData.setGuard("AValidGuard");
 398         responseString = validation.validatePolicy(policyData).toString();
 399         assertThat(responseString).contains("Config Name Should not be Empty");
 400
 401         policyData.setConfigName("%%%$$$$");
 402         responseString = validation.validatePolicy(policyData).toString();
 403         assertThat(responseString).contains("ConfigName:The Value in Required Field");
 404
 405         policyData.setConfigName("AValidConfigName");
 406         responseString = validation.validatePolicy(policyData).toString();
 407         assertThat(responseString).contains("Config Type Should not be Empty");
 408
 409         policyData.setConfigType("%%%$$$$");
 410         responseString = validation.validatePolicy(policyData).toString();
 411         assertThat(responseString).contains("ConfigType:The Value in Required Field");
 412
 413         policyData.setConfigType("AValidConfigType");
 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         assertThat(responseString).contains("Config Body Should not be Empty");
 420
 421         policyData.setConfigBodyData("%%%$$$$");
 422         responseString = validation.validatePolicy(policyData).toString();
 423         assertEquals("success@#", responseString);
 424
 425         policyData.setConfigType(null);
 426         policyData.setConfigBodyData("ValidConfigBodyData");
 427         responseString = validation.validatePolicy(policyData).toString();
 428         assertThat(responseString).contains("Config Type Should not be Empty");
 429
 430         policyData.setConfigType("JSON");
 431         policyData.setConfigBodyData("{");
 432         responseString = validation.validatePolicy(policyData).toString();
 433         assertThat(responseString).contains("Config Body: JSON Content is not valid");
 434
 435         policyData.setConfigBodyData("ValidConfigBodyData");
 436         responseString = validation.validatePolicy(policyData).toString();
 437         assertEquals("success@#", responseString);
 438
 439         policyData.setConfigType("XML");
 440         policyData.setConfigBodyData("{");
 441         responseString = validation.validatePolicy(policyData).toString();
 442         assertThat(responseString).contains("Config Body: XML Content data is not valid");
 443
 444         policyData.setConfigBodyData("<tag>value</tag>");
 445         responseString = validation.validatePolicy(policyData).toString();
 446         assertEquals("success@#", responseString);
 447
 448         policyData.setConfigType("PROPERTIES");
 449         policyData.setConfigBodyData("{");
 450         responseString = validation.validatePolicy(policyData).toString();
 451         assertThat(responseString).contains("Config Body: Property data is not valid");
 452
 453         policyData.setConfigBodyData("propertyName=PropertyValue");
 454         responseString = validation.validatePolicy(policyData).toString();
 455         assertEquals("success@#", responseString);
 456     }
 457
 458     @Test
 459     public void testPolicyConfigFirewallValidation() throws IOException {
 460         PolicyValidation validation = new PolicyValidation();
 461         PolicyRestAdapter policyData = new PolicyRestAdapter();
 462         policyData.setPolicyName("ALegalPolicyName");
 463         policyData.setPolicyDescription("A Valid Description");
 464
 465         String responseString = validation.validatePolicy(policyData).toString();
 466         assertEquals("success", responseString);
 467
 468         policyData.setApiflag("API");
 469         responseString = validation.validatePolicy(policyData).toString();
 470         assertEquals("success", responseString);
 471
 472         // Invalid values tested in config base test
 473         policyData.setOnapName("AValidOnapName");
 474         policyData.setRiskType("AValidRiskType");
 475         policyData.setRiskLevel("AValidRiskLevel");
 476         policyData.setGuard("AValidGuard");
 477         assertEquals("success", responseString);
 478
 479         policyData.setPolicyType("Config");
 480         policyData.setConfigPolicyType("Firewall Config");
 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("Config Name is required");
 487
 488         policyData.setConfigName("%%%$$$$");
 489         responseString = validation.validatePolicy(policyData).toString();
 490         assertThat(responseString).contains("<b>ConfigName</b>:<i>The Value in Required Field");
 491
 492         policyData.setConfigName("AValidConfigName");
 493         responseString = validation.validatePolicy(policyData).toString();
 494         assertThat(responseString).contains("Security Zone is required");
 495
 496         policyData.setSecurityZone("");
 497         responseString = validation.validatePolicy(policyData).toString();
 498         assertThat(responseString).contains("Security Zone is required");
 499
 500         policyData.setSecurityZone("AValidSeurityZone");
 501         responseString = validation.validatePolicy(policyData).toString();
 502         assertEquals("success@#", responseString);
 503     }
 504
 505     @Test
 506     public void testPolicyConfigBRMSValidation() throws IOException {
 507         PolicyValidation validation = new PolicyValidation();
 508         PolicyRestAdapter policyData = new PolicyRestAdapter();
 509         policyData.setPolicyName("ALegalPolicyName");
 510         policyData.setPolicyDescription("A Valid Description");
 511
 512         String responseString = validation.validatePolicy(policyData).toString();
 513         assertEquals("success", responseString);
 514
 515         policyData.setApiflag("API");
 516         responseString = validation.validatePolicy(policyData).toString();
 517         assertEquals("success", responseString);
 518
 519         // Invalid values tested in config base test
 520         policyData.setOnapName("AValidOnapName");
 521         policyData.setRiskType("AValidRiskType");
 522         policyData.setRiskLevel("AValidRiskLevel");
 523         policyData.setGuard("AValidGuard");
 524         assertEquals("success", responseString);
 525
 526         policyData.setPolicyType("Config");
 527         policyData.setConfigPolicyType("BRMS_Param");
 528         responseString = validation.validatePolicy(policyData).toString();
 529         assertThat(responseString).contains("BRMS Template is required");
 530
 531         policyData.setRuleName("");
 532         responseString = validation.validatePolicy(policyData).toString();
 533         assertThat(responseString).contains("BRMS Template is required");
 534
 535         policyData.setRuleName("AValidRuleName");
 536         responseString = validation.validatePolicy(policyData).toString();
 537         assertEquals("success@#", responseString);
 538         policyData.setRuleName(null);
 539
 540         policyData.setConfigPolicyType("BRMS_Raw");
 541         responseString = validation.validatePolicy(policyData).toString();
 542         assertThat(responseString).contains("Raw Rule is required");
 543
 544         policyData.setConfigBodyData("");
 545         responseString = validation.validatePolicy(policyData).toString();
 546         assertThat(responseString).contains("Raw Rule is required");
 547
 548         policyData.setConfigBodyData("InvalidConfigBodyData");
 549         responseString = validation.validatePolicy(policyData).toString();
 550         assertThat(responseString).contains("expecting one of the following tokens");
 551
 552         policyData.setConfigBodyData("import org.onap.policy.test.DummyTestSomething;");
 553         responseString = validation.validatePolicy(policyData).toString();
 554         assertEquals("success@#", responseString);
 555     }
 556
 557     @Test
 558     public void testPolicyConfigCloseLoopPmValidation() throws IOException {
 559         PolicyValidation validation = new PolicyValidation();
 560         PolicyRestAdapter policyData = new PolicyRestAdapter();
 561         policyData.setPolicyName("ALegalPolicyName");
 562         policyData.setPolicyDescription("A Valid Description");
 563
 564         String responseString = validation.validatePolicy(policyData).toString();
 565         assertEquals("success", responseString);
 566
 567         policyData.setApiflag("API");
 568         responseString = validation.validatePolicy(policyData).toString();
 569         assertEquals("success", responseString);
 570
 571         // Invalid values tested in config base test
 572         policyData.setOnapName("AValidOnapName");
 573         policyData.setRiskType("AValidRiskType");
 574         policyData.setRiskLevel("AValidRiskLevel");
 575         policyData.setGuard("AValidGuard");
 576         assertEquals("success", responseString);
 577
 578         policyData.setPolicyType("Config");
 579         policyData.setConfigPolicyType("ClosedLoop_PM");
 580         responseString = validation.validatePolicy(policyData).toString();
 581         assertThat(responseString).contains("ServiceType PolicyName is required");
 582
 583         Map<String, String> serviceTypePolicyName = null;
 584         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 585         responseString = validation.validatePolicy(policyData).toString();
 586         assertThat(responseString).contains("ServiceType PolicyName is required");
 587
 588         serviceTypePolicyName = new LinkedHashMap<>();
 589         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 590         responseString = validation.validatePolicy(policyData).toString();
 591         assertThat(responseString).contains("ServiceType PolicyName is required");
 592
 593         serviceTypePolicyName.put("AKey", "AValue");
 594         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 595         responseString = validation.validatePolicy(policyData).toString();
 596         assertThat(responseString).contains("ServiceType PolicyName is required");
 597         serviceTypePolicyName.clear();
 598
 599         serviceTypePolicyName.put("serviceTypePolicyName", "");
 600         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 601         responseString = validation.validatePolicy(policyData).toString();
 602         assertThat(responseString).contains("ServiceType PolicyName is required");
 603
 604         serviceTypePolicyName.put("serviceTypePolicyName", "AValidserviceTypePolicyName");
 605         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 606         responseString = validation.validatePolicy(policyData).toString();
 607         assertThat(responseString).contains("Select at least one D2");
 608
 609         policyData.setJsonBody("");
 610         assertNull(validation.validatePolicy(policyData));
 611
 612         policyData.setJsonBody("InvalidConfigBodyData");
 613         assertNull(validation.validatePolicy(policyData));
 614
 615         policyData.setJsonBody("{}");
 616         responseString = validation.validatePolicy(policyData).toString();
 617         assertThat(responseString).contains("Select at least one D2");
 618
 619         policyData.setJsonBody("{\"gamma\": false}");
 620         responseString = validation.validatePolicy(policyData).toString();
 621         assertThat(responseString).contains("Select at least one D2");
 622
 623         policyData.setJsonBody("{\"gamma\": true}");
 624         responseString = validation.validatePolicy(policyData).toString();
 625         assertEquals("success@#", responseString);
 626
 627         policyData.setJsonBody("{\"mcr\": false}");
 628         responseString = validation.validatePolicy(policyData).toString();
 629         assertThat(responseString).contains("Select at least one D2");
 630
 631         policyData.setJsonBody("{\"mcr\": true}");
 632         responseString = validation.validatePolicy(policyData).toString();
 633         assertEquals("success@#", responseString);
 634
 635         policyData.setJsonBody("{\"trinity\": false}");
 636         responseString = validation.validatePolicy(policyData).toString();
 637         assertThat(responseString).contains("Select at least one D2");
 638
 639         policyData.setJsonBody("{\"trinity\": true}");
 640         responseString = validation.validatePolicy(policyData).toString();
 641         assertEquals("success@#", responseString);
 642
 643         policyData.setJsonBody("{\"vDNS\": false}");
 644         responseString = validation.validatePolicy(policyData).toString();
 645         assertThat(responseString).contains("Select at least one D2");
 646
 647         policyData.setJsonBody("{\"vDNS\": true}");
 648         responseString = validation.validatePolicy(policyData).toString();
 649         assertEquals("success@#", responseString);
 650
 651         policyData.setJsonBody("{\"vUSP\": false}");
 652         responseString = validation.validatePolicy(policyData).toString();
 653         assertThat(responseString).contains("Select at least one D2");
 654
 655         policyData.setJsonBody("{\"vUSP\": true}");
 656         responseString = validation.validatePolicy(policyData).toString();
 657         assertEquals("success@#", responseString);
 658
 659         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
 660         responseString = validation.validatePolicy(policyData).toString();
 661         assertEquals("success@#", responseString);
 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\": \"%%%$$$\"}");
 668         responseString = validation.validatePolicy(policyData).toString();
 669         assertThat(responseString).contains("Email Address is not Valid");
 670
 671         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}");
 672         responseString = validation.validatePolicy(policyData).toString();
 673         assertEquals("success@#", responseString);
 674
 675         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": null}");
 676         responseString = validation.validatePolicy(policyData).toString();
 677         assertEquals("success@#", responseString);
 678
 679         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"\"}");
 680         responseString = validation.validatePolicy(policyData).toString();
 681         assertEquals("success@#", responseString);
 682
 683         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"$$$%%%\"}");
 684         responseString = validation.validatePolicy(policyData).toString();
 685         assertThat(responseString).contains("The Value in Required Field");
 686
 687         policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"AValidGeoLink\"}");
 688         responseString = validation.validatePolicy(policyData).toString();
 689         assertEquals("success@#", responseString);
 690
 691         policyData.setJsonBody("{\"trinity\": true, \"attributes\": null}");
 692         responseString = validation.validatePolicy(policyData).toString();
 693         assertEquals("success@#", responseString);
 694
 695         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {}}");
 696         responseString = validation.validatePolicy(policyData).toString();
 697         assertEquals("success@#", responseString);
 698
 699         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"av0\"}}");
 700         responseString = validation.validatePolicy(policyData).toString();
 701         assertEquals("success@#", responseString);
 702
 703         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"$$$%%%\"}}");
 704         responseString = validation.validatePolicy(policyData).toString();
 705         assertThat(responseString).contains("value has spaces or invalid characters");
 706
 707         policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"Message\":\"$$$%%%\"}}");
 708         responseString = validation.validatePolicy(policyData).toString();
 709         assertEquals("success@#", responseString);
 710     }
 711
 712     @Test
 713     public void testPolicyConfigCloseLoopFaultValidation() throws IOException {
 714         PolicyValidation validation = new PolicyValidation();
 715         PolicyRestAdapter policyData = new PolicyRestAdapter();
 716         policyData.setPolicyName("ALegalPolicyName");
 717         policyData.setPolicyDescription("A Valid Description");
 718
 719         String responseString = validation.validatePolicy(policyData).toString();
 720         assertEquals("success", responseString);
 721
 722         policyData.setApiflag("API");
 723         responseString = validation.validatePolicy(policyData).toString();
 724         assertEquals("success", responseString);
 725
 726         // Invalid values tested in config base test
 727         policyData.setOnapName("AValidOnapName");
 728         policyData.setRiskType("AValidRiskType");
 729         policyData.setRiskLevel("AValidRiskLevel");
 730         policyData.setGuard("AValidGuard");
 731         assertEquals("success", responseString);
 732
 733         policyData.setPolicyType("Config");
 734         policyData.setConfigPolicyType("ClosedLoop_Fault");
 735         responseString = validation.validatePolicy(policyData).toString();
 736         assertThat(responseString).contains("Select at least one D2");
 737
 738         policyData.setJsonBody("");
 739         assertNull(validation.validatePolicy(policyData));
 740
 741         policyData.setJsonBody("InvalidConfigBodyData");
 742         assertNull(validation.validatePolicy(policyData));
 743
 744         policyData.setJsonBody("{}");
 745         responseString = validation.validatePolicy(policyData).toString();
 746         assertThat(responseString).contains("There were no conditions provided in configBody json");
 747
 748         policyData.setJsonBody("{\"conditions\": null}");
 749         responseString = validation.validatePolicy(policyData).toString();
 750         assertThat(responseString).contains("There were no conditions provided in configBody json");
 751
 752         policyData.setJsonBody("{\"conditions\": \"\"}");
 753         responseString = validation.validatePolicy(policyData).toString();
 754         assertThat(responseString).contains("Select At least one Condition");
 755
 756         policyData.setJsonBody("{\"conditions\": \"AValidCondition\"}");
 757         assertNull(validation.validatePolicy(policyData));
 758
 759         policyData.setApiflag("NOAPI");
 760
 761         policyData.setJsonBody("");
 762         assertNull(validation.validatePolicy(policyData));
 763
 764         policyData.setJsonBody("InvalidConfigBodyData");
 765         assertNull(validation.validatePolicy(policyData));
 766
 767         ClosedLoopFaultTrapDatas trapDatas = new ClosedLoopFaultTrapDatas();
 768         policyData.setTrapDatas(trapDatas);
 769
 770         ClosedLoopFaultTrapDatas faultDatas = new ClosedLoopFaultTrapDatas();
 771         policyData.setFaultDatas(faultDatas);
 772
 773         policyData.setJsonBody("{}");
 774         assertThat(responseString).contains("Select At least one Condition");
 775
 776         List<Object> trap1 = new ArrayList<>();
 777         trapDatas.setTrap1(trap1);
 778         responseString = validation.validatePolicy(policyData).toString();
 779         assertThat(responseString).contains("Trigger Clear TimeOut is required");
 780
 781         policyData.setClearTimeOut("AValidClearTimeout");
 782         responseString = validation.validatePolicy(policyData).toString();
 783         assertThat(responseString).contains("Trap Max Age is required");
 784
 785         policyData.setTrapMaxAge("AValidTrapMaxAge");
 786         responseString = validation.validatePolicy(policyData).toString();
 787         assertThat(responseString).contains("Select at least one D2");
 788
 789         trapDatas.setTrap1(null);
 790         responseString = validation.validatePolicy(policyData).toString();
 791         assertThat(responseString).contains("Select at least one D2");
 792
 793         faultDatas.setTrap1(null);
 794         responseString = validation.validatePolicy(policyData).toString();
 795         assertThat(responseString).contains("Select at least one D2");
 796
 797         faultDatas.setTrap1(trap1);
 798         responseString = validation.validatePolicy(policyData).toString();
 799         assertThat(responseString).contains("Fault Clear TimeOut is required when");
 800
 801         policyData.setVerificationclearTimeOut("AValidVerificationClearTimeout");
 802         responseString = validation.validatePolicy(policyData).toString();
 803         assertThat(responseString).contains("Select at least one D2");
 804
 805         policyData.setJsonBody("{\"gamma\": false}");
 806         responseString = validation.validatePolicy(policyData).toString();
 807         assertThat(responseString).contains("Select at least one D2");
 808
 809         policyData.setJsonBody("{\"gamma\": true}");
 810         responseString = validation.validatePolicy(policyData).toString();
 811         assertThat(responseString).contains("vPRO Actions is required");
 812
 813         policyData.setJsonBody("{\"mcr\": false}");
 814         responseString = validation.validatePolicy(policyData).toString();
 815         assertThat(responseString).contains("Select at least one D2");
 816
 817         policyData.setJsonBody("{\"mcr\": true}");
 818         responseString = validation.validatePolicy(policyData).toString();
 819         assertThat(responseString).contains("vPRO Actions is required");
 820
 821         policyData.setJsonBody("{\"trinity\": false}");
 822         responseString = validation.validatePolicy(policyData).toString();
 823         assertThat(responseString).contains("Select at least one D2");
 824
 825         policyData.setJsonBody("{\"trinity\": true}");
 826         responseString = validation.validatePolicy(policyData).toString();
 827         assertThat(responseString).contains("vPRO Actions is required");
 828
 829         policyData.setJsonBody("{\"vDNS\": false}");
 830         responseString = validation.validatePolicy(policyData).toString();
 831         assertThat(responseString).contains("Select at least one D2");
 832
 833         policyData.setJsonBody("{\"vDNS\": true}");
 834         responseString = validation.validatePolicy(policyData).toString();
 835         assertThat(responseString).contains("vPRO Actions is required");
 836
 837         policyData.setJsonBody("{\"vUSP\": false}");
 838         responseString = validation.validatePolicy(policyData).toString();
 839         assertThat(responseString).contains("Select at least one D2");
 840
 841         policyData.setJsonBody("{\"vUSP\": true}");
 842         responseString = validation.validatePolicy(policyData).toString();
 843         assertThat(responseString).contains("vPRO Actions is required");
 844
 845         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
 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("vPRO Actions is required");
 852
 853         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"%%%$$$\"}");
 854         responseString = validation.validatePolicy(policyData).toString();
 855         assertThat(responseString).contains("Email Address is not Valid");
 856
 857         policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}");
 858         responseString = validation.validatePolicy(policyData).toString();
 859         assertThat(responseString).contains("vPRO Actions is required");
 860
 861         policyData.setJsonBody("{\"trinity\": true, \"actions\": null}");
 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("vPRO Actions is required");
 868
 869         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"$$$%%%\"}");
 870         responseString = validation.validatePolicy(policyData).toString();
 871         assertThat(responseString).contains("Policy Status is required");
 872         assertThat(responseString).contains("Vnf Type is required");
 873
 874         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\"}");
 875         responseString = validation.validatePolicy(policyData).toString();
 876         assertThat(responseString).contains("Policy Status is required");
 877
 878         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": null}");
 879         responseString = validation.validatePolicy(policyData).toString();
 880         assertThat(responseString).contains("Policy Status is required");
 881
 882         policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"\"}");
 883         responseString = validation.validatePolicy(policyData).toString();
 884         assertThat(responseString).contains("Policy Status is required");
 885
 886         policyData.setJsonBody(
 887                         "{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"$$$%%%\"}");
 888         responseString = validation.validatePolicy(policyData).toString();
 889         assertThat(responseString).contains("Select At least one Condition");
 890
 891         // @formatter:off
 892         policyData.setJsonBody("{"
 893                         + "\"trinity\": true,"
 894                         + "\"actions\": \"ValidActions\","
 895                         + "\"closedLoopPolicyStatus\": \"AValidStatus\""
 896                         + "}");
 897         // @formatter:on
 898         responseString = validation.validatePolicy(policyData).toString();
 899         assertThat(responseString).contains("Select At least one Condition");
 900
 901         // @formatter:off
 902         policyData.setJsonBody("{"
 903                         + "\"trinity\": true,"
 904                         + "\"actions\": \"ValidActions\","
 905                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 906                         + "\"conditions\": null"
 907                         + "}");
 908         // @formatter:on
 909         responseString = validation.validatePolicy(policyData).toString();
 910         assertThat(responseString).contains("Select At least one Condition");
 911
 912         // @formatter:off
 913         policyData.setJsonBody("{"
 914                         + "\"trinity\": true,"
 915                         + "\"actions\": \"ValidActions\","
 916                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 917                         + "\"conditions\": \"SEND\""
 918                         + "}");
 919         // @formatter:on
 920         responseString = validation.validatePolicy(policyData).toString();
 921         assertThat(responseString).contains("Aging Window is required");
 922
 923         // @formatter:off
 924         policyData.setJsonBody("{"
 925                         + "\"trinity\": true,"
 926                         + "\"actions\": \"ValidActions\","
 927                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 928                         + "\"conditions\": \"SEND\","
 929                         + "\"geoLink\": null"
 930                         + "}");
 931         // @formatter:on
 932         responseString = validation.validatePolicy(policyData).toString();
 933         assertThat(responseString).contains("Aging Window is required");
 934
 935         // @formatter:off
 936         policyData.setJsonBody("{"
 937                         + "\"trinity\": true,"
 938                         + "\"actions\": \"ValidActions\","
 939                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 940                         + "\"conditions\": \"SEND\","
 941                         + "\"geoLink\": \"\""
 942                         + "}");
 943         // @formatter:on
 944         responseString = validation.validatePolicy(policyData).toString();
 945         assertThat(responseString).contains("Aging Window is required");
 946
 947         // @formatter:off
 948         policyData.setJsonBody("{"
 949                         + "\"trinity\": true,"
 950                         + "\"actions\": \"ValidActions\","
 951                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 952                         + "\"conditions\": \"SEND\","
 953                         + "\"geoLink\": \"%%%$$$\""
 954                         + "}");
 955         // @formatter:on
 956         responseString = validation.validatePolicy(policyData).toString();
 957         assertThat(responseString).contains("GeoLink</b>:<i>The Value in Required Field");
 958
 959         // @formatter:off
 960         policyData.setJsonBody("{"
 961                         + "\"trinity\": true,"
 962                         + "\"actions\": \"ValidActions\","
 963                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 964                         + "\"conditions\": \"SEND\","
 965                         + "\"geoLink\": \"AValidGeoLink\""
 966                         + "}");
 967         // @formatter:on
 968         responseString = validation.validatePolicy(policyData).toString();
 969         assertThat(responseString).contains("Aging Window is required");
 970
 971         // @formatter:off
 972         policyData.setJsonBody("{"
 973                         + "\"trinity\": true,"
 974                         + "\"actions\": \"ValidActions\","
 975                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 976                         + "\"conditions\": \"SEND\","
 977                         + "\"agingWindow\": -1"
 978                         + "}");
 979         // @formatter:on
 980         responseString = validation.validatePolicy(policyData).toString();
 981         assertThat(responseString).contains("Time Interval is required");
 982
 983         // @formatter:off
 984         policyData.setJsonBody("{"
 985                         + "\"trinity\": true,"
 986                         + "\"actions\": \"ValidActions\","
 987                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
 988                         + "\"conditions\": \"SEND\","
 989                         + "\"agingWindow\": -1,"
 990                         + "\"timeInterval\": -1"
 991                         + "}");
 992         // @formatter:on
 993         responseString = validation.validatePolicy(policyData).toString();
 994         assertThat(responseString).contains("Number of Retries is required");
 995
 996         // @formatter:off
 997         policyData.setJsonBody("{"
 998                         + "\"trinity\": true,"
 999                         + "\"actions\": \"ValidActions\","
1000                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1001                         + "\"conditions\": \"SEND\","
1002                         + "\"agingWindow\": -1,"
1003                         + "\"timeInterval\": -1,"
1004                         + "\"retrys\": -1"
1005                         + "}");
1006         // @formatter:on
1007         responseString = validation.validatePolicy(policyData).toString();
1008         assertThat(responseString).contains("APP-C Timeout is required");
1009
1010         // @formatter:off
1011         policyData.setJsonBody("{"
1012                         + "\"trinity\": true,"
1013                         + "\"actions\": \"ValidActions\","
1014                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1015                         + "\"conditions\": \"SEND\","
1016                         + "\"agingWindow\": -1,"
1017                         + "\"timeInterval\": -1,"
1018                         + "\"retrys\": -1,"
1019                         + "\"timeOutvPRO\": -1"
1020                         + "}");
1021         // @formatter:on
1022         responseString = validation.validatePolicy(policyData).toString();
1023         assertThat(responseString).contains("TimeOutRuby is required");
1024
1025         // @formatter:off
1026         policyData.setJsonBody("{"
1027                         + "\"trinity\": true,"
1028                         + "\"actions\": \"ValidActions\","
1029                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1030                         + "\"conditions\": \"SEND\","
1031                         + "\"agingWindow\": -1,"
1032                         + "\"timeInterval\": -1,"
1033                         + "\"retrys\": -1,"
1034                         + "\"timeOutvPRO\": -1,"
1035                         + "\"timeOutRuby\": -1"
1036                         + "}");
1037         // @formatter:on
1038         responseString = validation.validatePolicy(policyData).toString();
1039         assertThat(responseString).contains("Vnf Type is required");
1040
1041         // @formatter:off
1042         policyData.setJsonBody("{"
1043                         + "\"trinity\": true,"
1044                         + "\"actions\": \"ValidActions\","
1045                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1046                         + "\"conditions\": \"SEND\","
1047                         + "\"agingWindow\": -1,"
1048                         + "\"timeInterval\": -1,"
1049                         + "\"retrys\": -1,"
1050                         + "\"timeOutvPRO\": -1,"
1051                         + "\"timeOutRuby\": -1,"
1052                         + "\"vnfType\": null"
1053                         + "}");
1054         // @formatter:on
1055         responseString = validation.validatePolicy(policyData).toString();
1056         assertThat(responseString).contains("Vnf Type is required");
1057
1058         // @formatter:off
1059         policyData.setJsonBody("{"
1060                         + "\"trinity\": true,"
1061                         + "\"actions\": \"ValidActions\","
1062                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1063                         + "\"conditions\": \"SEND\","
1064                         + "\"agingWindow\": -1,"
1065                         + "\"timeInterval\": -1,"
1066                         + "\"retrys\": -1,"
1067                         + "\"timeOutvPRO\": -1,"
1068                         + "\"timeOutRuby\": -1,"
1069                         + "\"vnfType\": \"\""
1070                         + "}");
1071         // @formatter:on
1072         responseString = validation.validatePolicy(policyData).toString();
1073         assertThat(responseString).contains("Vnf Type is required");
1074
1075         // @formatter:off
1076         policyData.setJsonBody("{"
1077                         + "\"trinity\": true,"
1078                         + "\"actions\": \"ValidActions\","
1079                         + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1080                         + "\"conditions\": \"SEND\","
1081                         + "\"agingWindow\": -1,"
1082                         + "\"timeInterval\": -1,"
1083                         + "\"retrys\": -1,"
1084                         + "\"timeOutvPRO\": -1,"
1085                         + "\"timeOutRuby\": -1,"
1086                         + "\"vnfType\": \"AValid VNF Type\""
1087                         + "}");
1088         // @formatter:on
1089         responseString = validation.validatePolicy(policyData).toString();
1090         assertEquals("success@#", responseString);
1091     }
1092
1093     @Test
1094     public void testPolicyConfigMicroServiceValidation() throws IOException {
1095         PolicyValidation validation = new PolicyValidation(commonClassDao);
1096         PolicyRestAdapter policyData = new PolicyRestAdapter();
1097         policyData.setPolicyName("ALegalPolicyName");
1098         policyData.setPolicyDescription("A Valid Description");
1099
1100         String responseString = validation.validatePolicy(policyData).toString();
1101         assertEquals("success", responseString);
1102
1103         policyData.setApiflag("NOAPI");
1104         responseString = validation.validatePolicy(policyData).toString();
1105         assertEquals("success", responseString);
1106
1107         // Invalid values tested in config base test
1108         policyData.setOnapName("AValidOnapName");
1109         policyData.setRiskType("AValidRiskType");
1110         policyData.setRiskLevel("AValidRiskLevel");
1111         policyData.setGuard("AValidGuard");
1112         assertEquals("success", responseString);
1113
1114         policyData.setPolicyType("Config");
1115         policyData.setConfigPolicyType("Micro Service");
1116         responseString = validation.validatePolicy(policyData).toString();
1117         assertThat(responseString).contains("Micro Service Model is required");
1118
1119         policyData.setServiceType("");
1120         responseString = validation.validatePolicy(policyData).toString();
1121         assertThat(responseString).contains("Micro Service Model is required");
1122
1123         policyData.setServiceType("ServiceType");
1124         assertNull(validation.validatePolicy(policyData));
1125
1126         policyData.setPolicyJSON("");
1127         assertNull(validation.validatePolicy(policyData));
1128
1129         String msJsonContentString0 = TextFileUtils
1130                         .getTextFileAsString("src/test/resources/policies/MicroServicePolicyContent0.json");
1131         policyData.setPolicyJSON(new ObjectMapper().readTree(msJsonContentString0));
1132         responseString = validation.validatePolicy(policyData).toString();
1133         assertThat(responseString).contains("Micro Service Version is required");
1134
1135         String msJsonContentString1 = TextFileUtils
1136                         .getTextFileAsString("src/test/resources/policies/MicroServicePolicyContent1.json");
1137         policyData.setPolicyJSON(new ObjectMapper().readTree(msJsonContentString1));
1138         responseString = validation.validatePolicy(policyData).toString();
1139         assertThat(responseString).contains("Micro Service Version is required");
1140
1141         policyData.setServiceType("ServiceType-vServiceVersion");
1142         responseString = validation.validatePolicy(policyData).toString();
1143         assertThat(responseString).contains("The model name, ServiceType of version, ServiceVersion was not found");
1144
1145         policyData.setServiceType("ServiceType");
1146         policyData.setRuleProvider("MicroService_Model");
1147         responseString = validation.validatePolicy(policyData).toString();
1148         assertThat(responseString).doesNotContain("Priority is required");
1149
1150         policyData.setVersion("ServiceVersion");
1151         Mockito.when(commonClassDao.getDataById(MicroServiceModels.class, "modelName:version",
1152                         "ServiceType:ServiceVersion")).thenReturn(null);
1153         responseString = validation.validatePolicy(policyData).toString();
1154         assertThat(responseString).contains("The model name, ServiceType of version, ServiceVersion was not found");
1155
1156         List<Object> msModelsList = new ArrayList<>();
1157         MicroServiceModels msModels = new MicroServiceModels();
1158         msModelsList.add(msModels);
1159         Mockito.when(commonClassDao.getDataById(MicroServiceModels.class, "modelName:version",
1160                         "ServiceType:ServiceVersion")).thenReturn(msModelsList);
1161         responseString = validation.validatePolicy(policyData).toString();
1162         assertEquals("success@#", responseString);
1163
1164         msModels.setAnnotation("SomeAnntation");
1165         assertNull(validation.validatePolicy(policyData));
1166
1167         msModels.setAnnotation("annotation0Key=annotation0Value");
1168         responseString = validation.validatePolicy(policyData).toString();
1169         assertEquals("success@#", responseString);
1170
1171         msModels.setAnnotation("annotation0Key=range::10-100");
1172         responseString = validation.validatePolicy(policyData).toString();
1173         assertThat(responseString).contains("annotation0Key is required for the MicroService model");
1174
1175         msModels.setAnnotation("police-instance-name=range::10-100");
1176         responseString = validation.validatePolicy(policyData).toString();
1177         assertThat(responseString).contains("Model Range:police-instance-name must be between 10 - 100");
1178
1179         msModels.setAnnotation("police-instance-range=range::12-100");
1180         responseString = validation.validatePolicy(policyData).toString();
1181         assertThat(responseString).contains("Model Range:police-instance-range must be between 12 - 100");
1182
1183         msModels.setAnnotation("police-instance-range=range::0-10");
1184         responseString = validation.validatePolicy(policyData).toString();
1185         assertThat(responseString).contains("Model Range:police-instance-range must be between 0 - 10");
1186
1187         msModels.setAnnotation("police-instance-range=range::10-100");
1188         responseString = validation.validatePolicy(policyData).toString();
1189         assertEquals("success@#", responseString);
1190
1191         msModels.setAnnotation(null);
1192         responseString = validation.validatePolicy(policyData).toString();
1193         assertEquals("success@#", responseString);
1194
1195         policyData.setRuleProvider("Not_MicroService_Model");
1196         responseString = validation.validatePolicy(policyData).toString();
1197         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> location is required for this model");
1198
1199         policyData.setLocation("AValidLocation");
1200         responseString = validation.validatePolicy(policyData).toString();
1201         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> configName is required for this model");
1202
1203         policyData.setConfigName("AValidConfigname");
1204         responseString = validation.validatePolicy(policyData).toString();
1205         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> uuid is required for this model");
1206
1207         policyData.setUuid("AValidUUID");
1208         responseString = validation.validatePolicy(policyData).toString();
1209         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> policyScope is required for this model");
1210
1211         policyData.setPolicyScope("AValidPolicyScope");
1212         responseString = validation.validatePolicy(policyData).toString();
1213         assertThat(responseString).contains("<b>Priority</b>:<i> Priority is required");
1214
1215         policyData.setPriority("AValidPriority");
1216         responseString = validation.validatePolicy(policyData).toString();
1217         assertEquals("success@#", responseString);
1218
1219         policyData.setApiflag("API");
1220         assertNull(validation.validatePolicy(policyData));
1221
1222         msModels.setSubAttributes("{}");
1223         responseString = validation.validatePolicy(policyData).toString();
1224         assertEquals("success@#", responseString);
1225
1226         msModels.setSubAttributes("{\"subAttrName0\": \"subAttrValue0\"}");
1227         responseString = validation.validatePolicy(policyData).toString();
1228         assertEquals("success@#", responseString);
1229
1230         msModels.setSubAttributes("{\"subAttrName0\": 10}");
1231         responseString = validation.validatePolicy(policyData).toString();
1232         assertEquals("success@#", responseString);
1233
1234         msModels.setSubAttributes("{\"subAttrName0\": {}}");
1235         responseString = validation.validatePolicy(policyData).toString();
1236         assertEquals("success@#", responseString);
1237
1238         msModels.setSubAttributes("{\"subAttrName0\": []}");
1239         responseString = validation.validatePolicy(policyData).toString();
1240         assertEquals("success@#", responseString);
1241
1242         msModels.setSubAttributes("{\"subAttrName0\": \"subAttrValue0-required-true\"}");
1243         responseString = validation.validatePolicy(policyData).toString();
1244         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1245
1246         msModels.setSubAttributes("{\"subAttrName0\": \":subAttrValue0-required-true\"}");
1247         responseString = validation.validatePolicy(policyData).toString();
1248         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1249
1250         msModels.setSubAttributes("{\"subAttrName0\": \"UnknownType:subAttrValue0-required-true\"}");
1251         responseString = validation.validatePolicy(policyData).toString();
1252         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1253
1254         msModels.setSubAttributes("{\"subAttrName0\": \"string:subAttrValue0-required-true\"}");
1255         responseString = validation.validatePolicy(policyData).toString();
1256         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1257
1258         msModels.setRefAttributes("refAttrName0=");
1259         responseString = validation.validatePolicy(policyData).toString();
1260         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1261
1262         msModels.setRefAttributes("refAttrName0=refAttrValue0");
1263         responseString = validation.validatePolicy(policyData).toString();
1264         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1265
1266         msModels.setRefAttributes("refAttrName0=refAttrValue0-required-true");
1267         responseString = validation.validatePolicy(policyData).toString();
1268         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1269
1270         msModels.setAttributes("");
1271         responseString = validation.validatePolicy(policyData).toString();
1272         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1273
1274         msModels.setAttributes("modelAttrName0=modelAttrValue0");
1275         responseString = validation.validatePolicy(policyData).toString();
1276         assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1277
1278         msModels.setRefAttributes("refAttrName0=refAttrValue0-required-true,");
1279         responseString = validation.validatePolicy(policyData).toString();
1280         assertThat(responseString).contains("refAttrName0 is required");
1281
1282         msModels.setRefAttributes("police-instance-range=refAttrValue0-required-true,");
1283         responseString = validation.validatePolicy(policyData).toString();
1284         assertThat(responseString).doesNotContain("police-instance-range is required");
1285     }
1286 }