2 * ============LICENSE_START=======================================================
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
22 package org.onap.policy.rest.util;
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;
29 import com.fasterxml.jackson.databind.ObjectMapper;
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;
38 import java.util.UUID;
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;
55 @RunWith(MockitoJUnitRunner.class)
56 public class PolicyValidationTest {
58 private CommonClassDao commonClassDao;
61 public void setUp() throws Exception {
65 public void tearDown() throws Exception {
69 public void microServicePolicyTests() throws Exception {
70 PolicyParameters policyParameters = new PolicyParameters();
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());
88 PolicyValidationRequestWrapper wrapper = new PolicyValidationRequestWrapper();
89 PolicyRestAdapter policyData = wrapper.populateRequestParameters(policyParameters);
90 PolicyValidation validation = new PolicyValidation();
91 String responseString = validation.validatePolicy(policyData).toString();
93 assertNotSame("success", responseString);
95 new PolicyValidation(null);
96 assertNull(PolicyValidation.getCommonClassDao());
98 policyData.setConfigPolicyType("ClosedLoop_Fault");
99 responseString = validation.validatePolicy(policyData).toString();
100 assertThat(responseString).doesNotContain("success");
102 policyData.setConfigPolicyType("ClosedLoop_PM");
103 responseString = validation.validatePolicy(policyData).toString();
104 assertThat(responseString).doesNotContain("success");
106 policyData.setConfigPolicyType("Enforcer Config");
107 responseString = validation.validatePolicy(policyData).toString();
108 assertThat(responseString).doesNotContain("success");
110 policyData.setConfigPolicyType("Optimization");
111 responseString = validation.validatePolicy(policyData).toString();
112 assertThat(responseString).doesNotContain("success");
114 policyData.setConfigPolicyType("Strange");
115 responseString = validation.validatePolicy(policyData).toString();
116 assertThat(responseString).doesNotContain("success");
120 public void testPolicyHeadingValidation() throws IOException {
121 PolicyValidation validation = new PolicyValidation();
122 PolicyRestAdapter policyData = new PolicyRestAdapter();
124 String responseString = validation.validatePolicy(policyData).toString();
125 assertThat(responseString).contains("PolicyName Should not be empty");
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}");
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:");
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:");
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");
151 String responseString = validation.validatePolicy(policyData).toString();
152 assertEquals("success", responseString);
154 policyData.setApiflag("API");
155 responseString = validation.validatePolicy(policyData).toString();
156 assertEquals("success", responseString);
158 policyData.setApiflag("NOTAPI");
159 responseString = validation.validatePolicy(policyData).toString();
160 assertEquals("success", responseString);
162 List<Object> attributes = new ArrayList<>();
163 policyData.setAttributes(attributes);
164 responseString = validation.validatePolicy(policyData).toString();
165 assertEquals("success", responseString);
167 attributes.add(new String("hello"));
168 responseString = validation.validatePolicy(policyData).toString();
169 assertEquals("success", responseString);
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");
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>",
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>",
187 mapAttribute.clear();
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>",
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);
202 policyData.setConfigPolicyType("Base");
203 responseString = validation.validatePolicy(policyData).toString();
204 assertThat(responseString).contains("has one missing Attribute key");
206 policyData.setConfigPolicyType("BRMS_Param");
207 responseString = validation.validatePolicy(policyData).toString();
208 assertThat(responseString).contains("has one missing Attribute key");
210 policyData.setConfigPolicyType("BRMS_Raw");
211 responseString = validation.validatePolicy(policyData).toString();
212 assertThat(responseString).contains("has one missing Attribute key");
214 policyData.setConfigPolicyType(null);
215 responseString = validation.validatePolicy(policyData).toString();
216 assertThat(responseString).contains("Risk Level Should not be Empty");
218 mapAttribute.clear();
219 mapAttribute.put("value", "thevalue");
220 responseString = validation.validatePolicy(policyData).toString();
221 assertThat(responseString).contains("Risk Level Should not be Empty");
223 mapAttribute.put("value", "$$$%%%%");
224 responseString = validation.validatePolicy(policyData).toString();
225 assertThat(responseString).contains("Risk Level Should not be Empty");
227 policyData.setConfigPolicyType("Base");
228 responseString = validation.validatePolicy(policyData).toString();
229 assertThat(responseString).contains("value has spaces or invalid characters");
231 policyData.setConfigPolicyType("BRMS_Param");
232 responseString = validation.validatePolicy(policyData).toString();
233 assertThat(responseString).contains("value has spaces or invalid characters");
235 policyData.setConfigPolicyType("BRMS_Raw");
236 responseString = validation.validatePolicy(policyData).toString();
237 assertThat(responseString).contains("value has spaces or invalid characters");
239 policyData.setConfigPolicyType(null);
240 policyData.setPolicyType(null);
241 responseString = validation.validatePolicy(policyData).toString();
242 assertThat(responseString).contains("value has spaces or invalid characters");
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");
252 String responseString = validation.validatePolicy(policyData).toString();
253 assertEquals("success", responseString);
255 policyData.setApiflag("API");
256 responseString = validation.validatePolicy(policyData).toString();
257 assertEquals("success", responseString);
259 policyData.setApiflag("NOTAPI");
260 responseString = validation.validatePolicy(policyData).toString();
261 assertEquals("success", responseString);
263 List<Object> settings = new ArrayList<>();
264 policyData.setSettings(settings);
265 responseString = validation.validatePolicy(policyData).toString();
266 assertEquals("success", responseString);
268 settings.add("hello");
269 responseString = validation.validatePolicy(policyData).toString();
270 assertEquals("success", responseString);
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");
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);
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);
287 mapSetting.put("value", "thevalue");
288 responseString = validation.validatePolicy(policyData).toString();
289 assertThat(responseString).contains("has one missing Attribute key");
291 mapSetting.put("value", "$$$%%%");
292 responseString = validation.validatePolicy(policyData).toString();
293 assertThat(responseString).contains("value has spaces or invalid characters");
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");
303 String responseString = validation.validatePolicy(policyData).toString();
304 assertEquals("success", responseString);
306 policyData.setApiflag("API");
307 responseString = validation.validatePolicy(policyData).toString();
308 assertEquals("success", responseString);
310 policyData.setApiflag("NOTAPI");
311 responseString = validation.validatePolicy(policyData).toString();
312 assertEquals("success", responseString);
314 List<Object> ruleAlgorithmschoices = new ArrayList<>();
315 policyData.setRuleAlgorithmschoices(ruleAlgorithmschoices);
316 responseString = validation.validatePolicy(policyData).toString();
317 assertEquals("success", responseString);
319 ruleAlgorithmschoices.add("hello");
320 responseString = validation.validatePolicy(policyData).toString();
321 assertEquals("success", responseString);
322 ruleAlgorithmschoices.clear();
324 Map<String, String> mapChoice = new LinkedHashMap<>();
325 ruleAlgorithmschoices.add(mapChoice);
326 assertNull(validation.validatePolicy(policyData));
329 mapChoice.put("id", "TheID");
330 responseString = validation.validatePolicy(policyData).toString();
331 assertThat(responseString).contains("Field 1 value is not selected");
333 mapChoice.put("dynamicRuleAlgorithmField1", "Field1");
334 responseString = validation.validatePolicy(policyData).toString();
335 assertThat(responseString).contains("Field 2 value is not selected");
337 mapChoice.put("dynamicRuleAlgorithmCombo", "Combo");
338 responseString = validation.validatePolicy(policyData).toString();
339 assertThat(responseString).contains("Field 3 value is empty");
341 mapChoice.put("dynamicRuleAlgorithmField2", "Field2");
342 responseString = validation.validatePolicy(policyData).toString();
343 assertEquals("success", responseString);
345 mapChoice.put("dynamicRuleAlgorithmField2", "%%%$$$");
346 responseString = validation.validatePolicy(policyData).toString();
347 assertThat(responseString).contains("Field 3 value has special characters");
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");
357 String responseString = validation.validatePolicy(policyData).toString();
358 assertEquals("success", responseString);
360 policyData.setApiflag("API");
361 responseString = validation.validatePolicy(policyData).toString();
362 assertEquals("success", responseString);
364 policyData.setPolicyType("Config");
365 policyData.setConfigPolicyType("Base");
366 responseString = validation.validatePolicy(policyData).toString();
367 assertThat(responseString).contains("Onap Name Should not be empty");
369 policyData.setOnapName("%%%$$$$");
370 responseString = validation.validatePolicy(policyData).toString();
371 assertThat(responseString).contains("<b>OnapName</b>:<i>The Value in Required Field");
373 policyData.setOnapName("AValidOnapName");
374 responseString = validation.validatePolicy(policyData).toString();
375 assertThat(responseString).contains("Risk Level Should not be Empty");
377 policyData.setRiskType("%%%$$$$");
378 responseString = validation.validatePolicy(policyData).toString();
379 assertThat(responseString).contains("<b>RiskType</b>:<i>The Value in Required Field");
381 policyData.setRiskType("AValidRiskType");
382 responseString = validation.validatePolicy(policyData).toString();
383 assertThat(responseString).contains("Risk Level Should not be Empty");
385 policyData.setRiskLevel("%%%$$$$");
386 responseString = validation.validatePolicy(policyData).toString();
387 assertThat(responseString).contains("<b>RiskLevel</b>:<i>The Value in Required Field");
389 policyData.setRiskLevel("AValidRiskLevel");
390 responseString = validation.validatePolicy(policyData).toString();
391 assertThat(responseString).contains("Guard Value Should not be Empty");
393 policyData.setGuard("%%%$$$$");
394 responseString = validation.validatePolicy(policyData).toString();
395 assertThat(responseString).contains("<b>Guard</b>:<i>The Value in Required Field");
397 policyData.setGuard("AValidGuard");
398 responseString = validation.validatePolicy(policyData).toString();
399 assertThat(responseString).contains("Config Name Should not be Empty");
401 policyData.setConfigName("%%%$$$$");
402 responseString = validation.validatePolicy(policyData).toString();
403 assertThat(responseString).contains("ConfigName:The Value in Required Field");
405 policyData.setConfigName("AValidConfigName");
406 responseString = validation.validatePolicy(policyData).toString();
407 assertThat(responseString).contains("Config Type Should not be Empty");
409 policyData.setConfigType("%%%$$$$");
410 responseString = validation.validatePolicy(policyData).toString();
411 assertThat(responseString).contains("ConfigType:The Value in Required Field");
413 policyData.setConfigType("AValidConfigType");
414 responseString = validation.validatePolicy(policyData).toString();
415 assertThat(responseString).contains("Config Body Should not be Empty");
417 policyData.setConfigBodyData("");
418 responseString = validation.validatePolicy(policyData).toString();
419 assertThat(responseString).contains("Config Body Should not be Empty");
421 policyData.setConfigBodyData("%%%$$$$");
422 responseString = validation.validatePolicy(policyData).toString();
423 assertEquals("success@#", responseString);
425 policyData.setConfigType(null);
426 policyData.setConfigBodyData("ValidConfigBodyData");
427 responseString = validation.validatePolicy(policyData).toString();
428 assertThat(responseString).contains("Config Type Should not be Empty");
430 policyData.setConfigType("JSON");
431 policyData.setConfigBodyData("{");
432 responseString = validation.validatePolicy(policyData).toString();
433 assertThat(responseString).contains("Config Body: JSON Content is not valid");
435 policyData.setConfigBodyData("ValidConfigBodyData");
436 responseString = validation.validatePolicy(policyData).toString();
437 assertEquals("success@#", responseString);
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");
444 policyData.setConfigBodyData("<tag>value</tag>");
445 responseString = validation.validatePolicy(policyData).toString();
446 assertEquals("success@#", responseString);
448 policyData.setConfigType("PROPERTIES");
449 policyData.setConfigBodyData("{");
450 responseString = validation.validatePolicy(policyData).toString();
451 assertThat(responseString).contains("Config Body: Property data is not valid");
453 policyData.setConfigBodyData("propertyName=PropertyValue");
454 responseString = validation.validatePolicy(policyData).toString();
455 assertEquals("success@#", responseString);
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");
465 String responseString = validation.validatePolicy(policyData).toString();
466 assertEquals("success", responseString);
468 policyData.setApiflag("API");
469 responseString = validation.validatePolicy(policyData).toString();
470 assertEquals("success", responseString);
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);
479 policyData.setPolicyType("Config");
480 policyData.setConfigPolicyType("Firewall Config");
481 responseString = validation.validatePolicy(policyData).toString();
482 assertThat(responseString).contains("Config Name is required");
484 policyData.setConfigName("");
485 responseString = validation.validatePolicy(policyData).toString();
486 assertThat(responseString).contains("Config Name is required");
488 policyData.setConfigName("%%%$$$$");
489 responseString = validation.validatePolicy(policyData).toString();
490 assertThat(responseString).contains("<b>ConfigName</b>:<i>The Value in Required Field");
492 policyData.setConfigName("AValidConfigName");
493 responseString = validation.validatePolicy(policyData).toString();
494 assertThat(responseString).contains("Security Zone is required");
496 policyData.setSecurityZone("");
497 responseString = validation.validatePolicy(policyData).toString();
498 assertThat(responseString).contains("Security Zone is required");
500 policyData.setSecurityZone("AValidSeurityZone");
501 responseString = validation.validatePolicy(policyData).toString();
502 assertEquals("success@#", responseString);
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");
512 String responseString = validation.validatePolicy(policyData).toString();
513 assertEquals("success", responseString);
515 policyData.setApiflag("API");
516 responseString = validation.validatePolicy(policyData).toString();
517 assertEquals("success", responseString);
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);
526 policyData.setPolicyType("Config");
527 policyData.setConfigPolicyType("BRMS_Param");
528 responseString = validation.validatePolicy(policyData).toString();
529 assertThat(responseString).contains("BRMS Template is required");
531 policyData.setRuleName("");
532 responseString = validation.validatePolicy(policyData).toString();
533 assertThat(responseString).contains("BRMS Template is required");
535 policyData.setRuleName("AValidRuleName");
536 responseString = validation.validatePolicy(policyData).toString();
537 assertEquals("success@#", responseString);
538 policyData.setRuleName(null);
540 policyData.setConfigPolicyType("BRMS_Raw");
541 responseString = validation.validatePolicy(policyData).toString();
542 assertThat(responseString).contains("Raw Rule is required");
544 policyData.setConfigBodyData("");
545 responseString = validation.validatePolicy(policyData).toString();
546 assertThat(responseString).contains("Raw Rule is required");
548 policyData.setConfigBodyData("InvalidConfigBodyData");
549 responseString = validation.validatePolicy(policyData).toString();
550 assertThat(responseString).contains("expecting one of the following tokens");
552 policyData.setConfigBodyData("import org.onap.policy.test.DummyTestSomething;");
553 responseString = validation.validatePolicy(policyData).toString();
554 assertEquals("success@#", responseString);
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");
564 String responseString = validation.validatePolicy(policyData).toString();
565 assertEquals("success", responseString);
567 policyData.setApiflag("API");
568 responseString = validation.validatePolicy(policyData).toString();
569 assertEquals("success", responseString);
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);
578 policyData.setPolicyType("Config");
579 policyData.setConfigPolicyType("ClosedLoop_PM");
580 responseString = validation.validatePolicy(policyData).toString();
581 assertThat(responseString).contains("ServiceType PolicyName is required");
583 Map<String, String> serviceTypePolicyName = null;
584 policyData.setServiceTypePolicyName(serviceTypePolicyName);
585 responseString = validation.validatePolicy(policyData).toString();
586 assertThat(responseString).contains("ServiceType PolicyName is required");
588 serviceTypePolicyName = new LinkedHashMap<>();
589 policyData.setServiceTypePolicyName(serviceTypePolicyName);
590 responseString = validation.validatePolicy(policyData).toString();
591 assertThat(responseString).contains("ServiceType PolicyName is required");
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();
599 serviceTypePolicyName.put("serviceTypePolicyName", "");
600 policyData.setServiceTypePolicyName(serviceTypePolicyName);
601 responseString = validation.validatePolicy(policyData).toString();
602 assertThat(responseString).contains("ServiceType PolicyName is required");
604 serviceTypePolicyName.put("serviceTypePolicyName", "AValidserviceTypePolicyName");
605 policyData.setServiceTypePolicyName(serviceTypePolicyName);
606 responseString = validation.validatePolicy(policyData).toString();
607 assertThat(responseString).contains("Select at least one D2");
609 policyData.setJsonBody("");
610 assertNull(validation.validatePolicy(policyData));
612 policyData.setJsonBody("InvalidConfigBodyData");
613 assertNull(validation.validatePolicy(policyData));
615 policyData.setJsonBody("{}");
616 responseString = validation.validatePolicy(policyData).toString();
617 assertThat(responseString).contains("Select at least one D2");
619 policyData.setJsonBody("{\"gamma\": false}");
620 responseString = validation.validatePolicy(policyData).toString();
621 assertThat(responseString).contains("Select at least one D2");
623 policyData.setJsonBody("{\"gamma\": true}");
624 responseString = validation.validatePolicy(policyData).toString();
625 assertEquals("success@#", responseString);
627 policyData.setJsonBody("{\"mcr\": false}");
628 responseString = validation.validatePolicy(policyData).toString();
629 assertThat(responseString).contains("Select at least one D2");
631 policyData.setJsonBody("{\"mcr\": true}");
632 responseString = validation.validatePolicy(policyData).toString();
633 assertEquals("success@#", responseString);
635 policyData.setJsonBody("{\"trinity\": false}");
636 responseString = validation.validatePolicy(policyData).toString();
637 assertThat(responseString).contains("Select at least one D2");
639 policyData.setJsonBody("{\"trinity\": true}");
640 responseString = validation.validatePolicy(policyData).toString();
641 assertEquals("success@#", responseString);
643 policyData.setJsonBody("{\"vDNS\": false}");
644 responseString = validation.validatePolicy(policyData).toString();
645 assertThat(responseString).contains("Select at least one D2");
647 policyData.setJsonBody("{\"vDNS\": true}");
648 responseString = validation.validatePolicy(policyData).toString();
649 assertEquals("success@#", responseString);
651 policyData.setJsonBody("{\"vUSP\": false}");
652 responseString = validation.validatePolicy(policyData).toString();
653 assertThat(responseString).contains("Select at least one D2");
655 policyData.setJsonBody("{\"vUSP\": true}");
656 responseString = validation.validatePolicy(policyData).toString();
657 assertEquals("success@#", responseString);
659 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
660 responseString = validation.validatePolicy(policyData).toString();
661 assertEquals("success@#", responseString);
663 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}");
664 responseString = validation.validatePolicy(policyData).toString();
665 assertThat(responseString).contains("Email Address is not Valid");
667 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"%%%$$$\"}");
668 responseString = validation.validatePolicy(policyData).toString();
669 assertThat(responseString).contains("Email Address is not Valid");
671 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}");
672 responseString = validation.validatePolicy(policyData).toString();
673 assertEquals("success@#", responseString);
675 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": null}");
676 responseString = validation.validatePolicy(policyData).toString();
677 assertEquals("success@#", responseString);
679 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"\"}");
680 responseString = validation.validatePolicy(policyData).toString();
681 assertEquals("success@#", responseString);
683 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"$$$%%%\"}");
684 responseString = validation.validatePolicy(policyData).toString();
685 assertThat(responseString).contains("The Value in Required Field");
687 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"AValidGeoLink\"}");
688 responseString = validation.validatePolicy(policyData).toString();
689 assertEquals("success@#", responseString);
691 policyData.setJsonBody("{\"trinity\": true, \"attributes\": null}");
692 responseString = validation.validatePolicy(policyData).toString();
693 assertEquals("success@#", responseString);
695 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {}}");
696 responseString = validation.validatePolicy(policyData).toString();
697 assertEquals("success@#", responseString);
699 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"av0\"}}");
700 responseString = validation.validatePolicy(policyData).toString();
701 assertEquals("success@#", responseString);
703 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"$$$%%%\"}}");
704 responseString = validation.validatePolicy(policyData).toString();
705 assertThat(responseString).contains("value has spaces or invalid characters");
707 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"Message\":\"$$$%%%\"}}");
708 responseString = validation.validatePolicy(policyData).toString();
709 assertEquals("success@#", responseString);
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");
719 String responseString = validation.validatePolicy(policyData).toString();
720 assertEquals("success", responseString);
722 policyData.setApiflag("API");
723 responseString = validation.validatePolicy(policyData).toString();
724 assertEquals("success", responseString);
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);
733 policyData.setPolicyType("Config");
734 policyData.setConfigPolicyType("ClosedLoop_Fault");
735 responseString = validation.validatePolicy(policyData).toString();
736 assertThat(responseString).contains("Select at least one D2");
738 policyData.setJsonBody("");
739 assertNull(validation.validatePolicy(policyData));
741 policyData.setJsonBody("InvalidConfigBodyData");
742 assertNull(validation.validatePolicy(policyData));
744 policyData.setJsonBody("{}");
745 responseString = validation.validatePolicy(policyData).toString();
746 assertThat(responseString).contains("There were no conditions provided in configBody json");
748 policyData.setJsonBody("{\"conditions\": null}");
749 responseString = validation.validatePolicy(policyData).toString();
750 assertThat(responseString).contains("There were no conditions provided in configBody json");
752 policyData.setJsonBody("{\"conditions\": \"\"}");
753 responseString = validation.validatePolicy(policyData).toString();
754 assertThat(responseString).contains("Select At least one Condition");
756 policyData.setJsonBody("{\"conditions\": \"AValidCondition\"}");
757 assertNull(validation.validatePolicy(policyData));
759 policyData.setApiflag("NOAPI");
761 policyData.setJsonBody("");
762 assertNull(validation.validatePolicy(policyData));
764 policyData.setJsonBody("InvalidConfigBodyData");
765 assertNull(validation.validatePolicy(policyData));
767 ClosedLoopFaultTrapDatas trapDatas = new ClosedLoopFaultTrapDatas();
768 policyData.setTrapDatas(trapDatas);
770 ClosedLoopFaultTrapDatas faultDatas = new ClosedLoopFaultTrapDatas();
771 policyData.setFaultDatas(faultDatas);
773 policyData.setJsonBody("{}");
774 assertThat(responseString).contains("Select At least one Condition");
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");
781 policyData.setClearTimeOut("AValidClearTimeout");
782 responseString = validation.validatePolicy(policyData).toString();
783 assertThat(responseString).contains("Trap Max Age is required");
785 policyData.setTrapMaxAge("AValidTrapMaxAge");
786 responseString = validation.validatePolicy(policyData).toString();
787 assertThat(responseString).contains("Select at least one D2");
789 trapDatas.setTrap1(null);
790 responseString = validation.validatePolicy(policyData).toString();
791 assertThat(responseString).contains("Select at least one D2");
793 faultDatas.setTrap1(null);
794 responseString = validation.validatePolicy(policyData).toString();
795 assertThat(responseString).contains("Select at least one D2");
797 faultDatas.setTrap1(trap1);
798 responseString = validation.validatePolicy(policyData).toString();
799 assertThat(responseString).contains("Fault Clear TimeOut is required when");
801 policyData.setVerificationclearTimeOut("AValidVerificationClearTimeout");
802 responseString = validation.validatePolicy(policyData).toString();
803 assertThat(responseString).contains("Select at least one D2");
805 policyData.setJsonBody("{\"gamma\": false}");
806 responseString = validation.validatePolicy(policyData).toString();
807 assertThat(responseString).contains("Select at least one D2");
809 policyData.setJsonBody("{\"gamma\": true}");
810 responseString = validation.validatePolicy(policyData).toString();
811 assertThat(responseString).contains("vPRO Actions is required");
813 policyData.setJsonBody("{\"mcr\": false}");
814 responseString = validation.validatePolicy(policyData).toString();
815 assertThat(responseString).contains("Select at least one D2");
817 policyData.setJsonBody("{\"mcr\": true}");
818 responseString = validation.validatePolicy(policyData).toString();
819 assertThat(responseString).contains("vPRO Actions is required");
821 policyData.setJsonBody("{\"trinity\": false}");
822 responseString = validation.validatePolicy(policyData).toString();
823 assertThat(responseString).contains("Select at least one D2");
825 policyData.setJsonBody("{\"trinity\": true}");
826 responseString = validation.validatePolicy(policyData).toString();
827 assertThat(responseString).contains("vPRO Actions is required");
829 policyData.setJsonBody("{\"vDNS\": false}");
830 responseString = validation.validatePolicy(policyData).toString();
831 assertThat(responseString).contains("Select at least one D2");
833 policyData.setJsonBody("{\"vDNS\": true}");
834 responseString = validation.validatePolicy(policyData).toString();
835 assertThat(responseString).contains("vPRO Actions is required");
837 policyData.setJsonBody("{\"vUSP\": false}");
838 responseString = validation.validatePolicy(policyData).toString();
839 assertThat(responseString).contains("Select at least one D2");
841 policyData.setJsonBody("{\"vUSP\": true}");
842 responseString = validation.validatePolicy(policyData).toString();
843 assertThat(responseString).contains("vPRO Actions is required");
845 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
846 responseString = validation.validatePolicy(policyData).toString();
847 assertThat(responseString).contains("vPRO Actions is required");
849 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}");
850 responseString = validation.validatePolicy(policyData).toString();
851 assertThat(responseString).contains("vPRO Actions is required");
853 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"%%%$$$\"}");
854 responseString = validation.validatePolicy(policyData).toString();
855 assertThat(responseString).contains("Email Address is not Valid");
857 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}");
858 responseString = validation.validatePolicy(policyData).toString();
859 assertThat(responseString).contains("vPRO Actions is required");
861 policyData.setJsonBody("{\"trinity\": true, \"actions\": null}");
862 responseString = validation.validatePolicy(policyData).toString();
863 assertThat(responseString).contains("vPRO Actions is required");
865 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"\"}");
866 responseString = validation.validatePolicy(policyData).toString();
867 assertThat(responseString).contains("vPRO Actions is required");
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");
874 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\"}");
875 responseString = validation.validatePolicy(policyData).toString();
876 assertThat(responseString).contains("Policy Status is required");
878 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": null}");
879 responseString = validation.validatePolicy(policyData).toString();
880 assertThat(responseString).contains("Policy Status is required");
882 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"\"}");
883 responseString = validation.validatePolicy(policyData).toString();
884 assertThat(responseString).contains("Policy Status is required");
886 policyData.setJsonBody(
887 "{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"$$$%%%\"}");
888 responseString = validation.validatePolicy(policyData).toString();
889 assertThat(responseString).contains("Select At least one Condition");
892 policyData.setJsonBody("{"
893 + "\"trinity\": true,"
894 + "\"actions\": \"ValidActions\","
895 + "\"closedLoopPolicyStatus\": \"AValidStatus\""
898 responseString = validation.validatePolicy(policyData).toString();
899 assertThat(responseString).contains("Select At least one Condition");
902 policyData.setJsonBody("{"
903 + "\"trinity\": true,"
904 + "\"actions\": \"ValidActions\","
905 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
906 + "\"conditions\": null"
909 responseString = validation.validatePolicy(policyData).toString();
910 assertThat(responseString).contains("Select At least one Condition");
913 policyData.setJsonBody("{"
914 + "\"trinity\": true,"
915 + "\"actions\": \"ValidActions\","
916 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
917 + "\"conditions\": \"SEND\""
920 responseString = validation.validatePolicy(policyData).toString();
921 assertThat(responseString).contains("Aging Window is required");
924 policyData.setJsonBody("{"
925 + "\"trinity\": true,"
926 + "\"actions\": \"ValidActions\","
927 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
928 + "\"conditions\": \"SEND\","
929 + "\"geoLink\": null"
932 responseString = validation.validatePolicy(policyData).toString();
933 assertThat(responseString).contains("Aging Window is required");
936 policyData.setJsonBody("{"
937 + "\"trinity\": true,"
938 + "\"actions\": \"ValidActions\","
939 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
940 + "\"conditions\": \"SEND\","
941 + "\"geoLink\": \"\""
944 responseString = validation.validatePolicy(policyData).toString();
945 assertThat(responseString).contains("Aging Window is required");
948 policyData.setJsonBody("{"
949 + "\"trinity\": true,"
950 + "\"actions\": \"ValidActions\","
951 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
952 + "\"conditions\": \"SEND\","
953 + "\"geoLink\": \"%%%$$$\""
956 responseString = validation.validatePolicy(policyData).toString();
957 assertThat(responseString).contains("GeoLink</b>:<i>The Value in Required Field");
960 policyData.setJsonBody("{"
961 + "\"trinity\": true,"
962 + "\"actions\": \"ValidActions\","
963 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
964 + "\"conditions\": \"SEND\","
965 + "\"geoLink\": \"AValidGeoLink\""
968 responseString = validation.validatePolicy(policyData).toString();
969 assertThat(responseString).contains("Aging Window is required");
972 policyData.setJsonBody("{"
973 + "\"trinity\": true,"
974 + "\"actions\": \"ValidActions\","
975 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
976 + "\"conditions\": \"SEND\","
977 + "\"agingWindow\": -1"
980 responseString = validation.validatePolicy(policyData).toString();
981 assertThat(responseString).contains("Time Interval is required");
984 policyData.setJsonBody("{"
985 + "\"trinity\": true,"
986 + "\"actions\": \"ValidActions\","
987 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
988 + "\"conditions\": \"SEND\","
989 + "\"agingWindow\": -1,"
990 + "\"timeInterval\": -1"
993 responseString = validation.validatePolicy(policyData).toString();
994 assertThat(responseString).contains("Number of Retries is required");
997 policyData.setJsonBody("{"
998 + "\"trinity\": true,"
999 + "\"actions\": \"ValidActions\","
1000 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1001 + "\"conditions\": \"SEND\","
1002 + "\"agingWindow\": -1,"
1003 + "\"timeInterval\": -1,"
1007 responseString = validation.validatePolicy(policyData).toString();
1008 assertThat(responseString).contains("APP-C Timeout is required");
1011 policyData.setJsonBody("{"
1012 + "\"trinity\": true,"
1013 + "\"actions\": \"ValidActions\","
1014 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1015 + "\"conditions\": \"SEND\","
1016 + "\"agingWindow\": -1,"
1017 + "\"timeInterval\": -1,"
1019 + "\"timeOutvPRO\": -1"
1022 responseString = validation.validatePolicy(policyData).toString();
1023 assertThat(responseString).contains("TimeOutRuby is required");
1026 policyData.setJsonBody("{"
1027 + "\"trinity\": true,"
1028 + "\"actions\": \"ValidActions\","
1029 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1030 + "\"conditions\": \"SEND\","
1031 + "\"agingWindow\": -1,"
1032 + "\"timeInterval\": -1,"
1034 + "\"timeOutvPRO\": -1,"
1035 + "\"timeOutRuby\": -1"
1038 responseString = validation.validatePolicy(policyData).toString();
1039 assertThat(responseString).contains("Vnf Type is required");
1042 policyData.setJsonBody("{"
1043 + "\"trinity\": true,"
1044 + "\"actions\": \"ValidActions\","
1045 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1046 + "\"conditions\": \"SEND\","
1047 + "\"agingWindow\": -1,"
1048 + "\"timeInterval\": -1,"
1050 + "\"timeOutvPRO\": -1,"
1051 + "\"timeOutRuby\": -1,"
1052 + "\"vnfType\": null"
1055 responseString = validation.validatePolicy(policyData).toString();
1056 assertThat(responseString).contains("Vnf Type is required");
1059 policyData.setJsonBody("{"
1060 + "\"trinity\": true,"
1061 + "\"actions\": \"ValidActions\","
1062 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1063 + "\"conditions\": \"SEND\","
1064 + "\"agingWindow\": -1,"
1065 + "\"timeInterval\": -1,"
1067 + "\"timeOutvPRO\": -1,"
1068 + "\"timeOutRuby\": -1,"
1069 + "\"vnfType\": \"\""
1072 responseString = validation.validatePolicy(policyData).toString();
1073 assertThat(responseString).contains("Vnf Type is required");
1076 policyData.setJsonBody("{"
1077 + "\"trinity\": true,"
1078 + "\"actions\": \"ValidActions\","
1079 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1080 + "\"conditions\": \"SEND\","
1081 + "\"agingWindow\": -1,"
1082 + "\"timeInterval\": -1,"
1084 + "\"timeOutvPRO\": -1,"
1085 + "\"timeOutRuby\": -1,"
1086 + "\"vnfType\": \"AValid VNF Type\""
1089 responseString = validation.validatePolicy(policyData).toString();
1090 assertEquals("success@#", responseString);
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");
1100 String responseString = validation.validatePolicy(policyData).toString();
1101 assertEquals("success", responseString);
1103 policyData.setApiflag("NOAPI");
1104 responseString = validation.validatePolicy(policyData).toString();
1105 assertEquals("success", responseString);
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);
1114 policyData.setPolicyType("Config");
1115 policyData.setConfigPolicyType("Micro Service");
1116 responseString = validation.validatePolicy(policyData).toString();
1117 assertThat(responseString).contains("Micro Service Model is required");
1119 policyData.setServiceType("");
1120 responseString = validation.validatePolicy(policyData).toString();
1121 assertThat(responseString).contains("Micro Service Model is required");
1123 policyData.setServiceType("ServiceType");
1124 assertNull(validation.validatePolicy(policyData));
1126 policyData.setPolicyJSON("");
1127 assertNull(validation.validatePolicy(policyData));
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");
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");
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");
1145 policyData.setServiceType("ServiceType");
1146 policyData.setRuleProvider("MicroService_Model");
1147 responseString = validation.validatePolicy(policyData).toString();
1148 assertThat(responseString).doesNotContain("Priority is required");
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");
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);
1164 msModels.setAnnotation("SomeAnntation");
1165 assertNull(validation.validatePolicy(policyData));
1167 msModels.setAnnotation("annotation0Key=annotation0Value");
1168 responseString = validation.validatePolicy(policyData).toString();
1169 assertEquals("success@#", responseString);
1171 msModels.setAnnotation("annotation0Key=range::10-100");
1172 responseString = validation.validatePolicy(policyData).toString();
1173 assertThat(responseString).contains("annotation0Key is required for the MicroService model");
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");
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");
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");
1187 msModels.setAnnotation("police-instance-range=range::10-100");
1188 responseString = validation.validatePolicy(policyData).toString();
1189 assertEquals("success@#", responseString);
1191 msModels.setAnnotation(null);
1192 responseString = validation.validatePolicy(policyData).toString();
1193 assertEquals("success@#", responseString);
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");
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");
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");
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");
1211 policyData.setPolicyScope("AValidPolicyScope");
1212 responseString = validation.validatePolicy(policyData).toString();
1213 assertThat(responseString).contains("<b>Priority</b>:<i> Priority is required");
1215 policyData.setPriority("AValidPriority");
1216 responseString = validation.validatePolicy(policyData).toString();
1217 assertEquals("success@#", responseString);
1219 policyData.setApiflag("API");
1220 assertNull(validation.validatePolicy(policyData));
1222 msModels.setSubAttributes("{}");
1223 responseString = validation.validatePolicy(policyData).toString();
1224 assertEquals("success@#", responseString);
1226 msModels.setSubAttributes("{\"subAttrName0\": \"subAttrValue0\"}");
1227 responseString = validation.validatePolicy(policyData).toString();
1228 assertEquals("success@#", responseString);
1230 msModels.setSubAttributes("{\"subAttrName0\": 10}");
1231 responseString = validation.validatePolicy(policyData).toString();
1232 assertEquals("success@#", responseString);
1234 msModels.setSubAttributes("{\"subAttrName0\": {}}");
1235 responseString = validation.validatePolicy(policyData).toString();
1236 assertEquals("success@#", responseString);
1238 msModels.setSubAttributes("{\"subAttrName0\": []}");
1239 responseString = validation.validatePolicy(policyData).toString();
1240 assertEquals("success@#", responseString);
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");
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");
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");
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");
1258 msModels.setRefAttributes("refAttrName0=");
1259 responseString = validation.validatePolicy(policyData).toString();
1260 assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1262 msModels.setRefAttributes("refAttrName0=refAttrValue0");
1263 responseString = validation.validatePolicy(policyData).toString();
1264 assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
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");
1270 msModels.setAttributes("");
1271 responseString = validation.validatePolicy(policyData).toString();
1272 assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1274 msModels.setAttributes("modelAttrName0=modelAttrValue0");
1275 responseString = validation.validatePolicy(policyData).toString();
1276 assertThat(responseString).contains("<b>Micro Service Model</b>:<i> subAttrName0 is required");
1278 msModels.setRefAttributes("refAttrName0=refAttrValue0-required-true,");
1279 responseString = validation.validatePolicy(policyData).toString();
1280 assertThat(responseString).contains("refAttrName0 is required");
1282 msModels.setRefAttributes("police-instance-range=refAttrValue0-required-true,");
1283 responseString = validation.validatePolicy(policyData).toString();
1284 assertThat(responseString).doesNotContain("police-instance-range is required");