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 java.io.IOException;
30 import java.text.SimpleDateFormat;
31 import java.util.ArrayList;
32 import java.util.Date;
33 import java.util.LinkedHashMap;
34 import java.util.List;
36 import java.util.UUID;
38 import org.junit.After;
39 import org.junit.Before;
40 import org.junit.Test;
41 import org.onap.policy.api.PolicyConfigType;
42 import org.onap.policy.api.PolicyParameters;
43 import org.onap.policy.common.utils.resources.TextFileUtils;
44 import org.onap.policy.rest.adapter.ClosedLoopFaultTrapDatas;
45 import org.onap.policy.rest.adapter.PolicyRestAdapter;
47 public class PolicyValidationTest {
50 public void setUp() throws Exception {
54 public void tearDown() throws Exception {
58 public void microServicePolicyTests() throws Exception {
59 PolicyParameters policyParameters = new PolicyParameters();
61 policyParameters.setPolicyConfigType(PolicyConfigType.MicroService);
62 policyParameters.setPolicyName("Test.junitPolicy");
63 policyParameters.setPolicyDescription("This is a sample Micro Service policy Create example");
64 policyParameters.setOnapName("DCAE");
65 policyParameters.setPriority("1");
66 String msJsonString = TextFileUtils.getTextFileAsString("src/test/resources/policies/MicroServicePolicy.json");
67 policyParameters.setConfigBody(msJsonString);
68 policyParameters.setRequestID(UUID.randomUUID());
69 SimpleDateFormat dateformat3 = new SimpleDateFormat("dd/MM/yyyy");
70 Date date = dateformat3.parse("15/10/2016");
71 policyParameters.setTtlDate(date);
72 policyParameters.setGuard(true);
73 policyParameters.setRiskLevel("5");
74 policyParameters.setRiskType("TEST");
75 policyParameters.setRequestID(UUID.randomUUID());
77 PolicyValidationRequestWrapper wrapper = new PolicyValidationRequestWrapper();
78 PolicyRestAdapter policyData = wrapper.populateRequestParameters(policyParameters);
79 PolicyValidation validation = new PolicyValidation();
80 String responseString = validation.validatePolicy(policyData).toString();
82 assertNotSame("success", responseString);
84 new PolicyValidation(null);
85 assertNull(PolicyValidation.getCommonClassDao());
87 policyData.setConfigPolicyType("ClosedLoop_Fault");
88 responseString = validation.validatePolicy(policyData).toString();
89 assertThat(responseString).doesNotContain("success");
91 policyData.setConfigPolicyType("ClosedLoop_PM");
92 responseString = validation.validatePolicy(policyData).toString();
93 assertThat(responseString).doesNotContain("success");
95 policyData.setConfigPolicyType("Enforcer Config");
96 responseString = validation.validatePolicy(policyData).toString();
97 assertThat(responseString).doesNotContain("success");
99 policyData.setConfigPolicyType("Optimization");
100 responseString = validation.validatePolicy(policyData).toString();
101 assertThat(responseString).doesNotContain("success");
103 policyData.setConfigPolicyType("Strange");
104 responseString = validation.validatePolicy(policyData).toString();
105 assertThat(responseString).doesNotContain("success");
109 public final void testEmailValidation() {
110 PolicyValidation validation = new PolicyValidation();
111 String result = validation.emailValidation("testemail@test.com", "SUCCESS");
112 assertEquals("success", result);
116 public void testPolicyHeadingValidation() throws IOException {
117 PolicyValidation validation = new PolicyValidation();
118 PolicyRestAdapter policyData = new PolicyRestAdapter();
120 String responseString = validation.validatePolicy(policyData).toString();
121 assertThat(responseString).contains("PolicyName Should not be empty");
123 policyData.setPolicyName("%%%~~~%%%");
124 responseString = validation.validatePolicy(policyData).toString();
125 assertThat(responseString).contains("The Value in Required Field will allow only '{0-9}, {a-z}, {A-Z}");
127 policyData.setPolicyName("ALegalPolicyName");
128 policyData.setPolicyDescription("@CreatedBy:");
129 responseString = validation.validatePolicy(policyData).toString();
130 assertThat(responseString)
131 .contains("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:");
132 policyData.setPolicyDescription("@CreatedBy:");
134 policyData.setPolicyDescription("A Legal Description");
135 responseString = validation.validatePolicy(policyData).toString();
136 assertThat(responseString)
137 .doesNotContain("The value in the description shouldn't contain @CreatedBy: or @ModifiedBy:");
141 public void testPolicyAttributeValidation() throws IOException {
142 PolicyValidation validation = new PolicyValidation();
143 PolicyRestAdapter policyData = new PolicyRestAdapter();
144 policyData.setPolicyName("ALegalPolicyName");
145 policyData.setPolicyDescription("A Valid Description");
147 String responseString = validation.validatePolicy(policyData).toString();
148 assertEquals("success", responseString);
150 policyData.setApiflag("API");
151 responseString = validation.validatePolicy(policyData).toString();
152 assertEquals("success", responseString);
154 policyData.setApiflag("NOTAPI");
155 responseString = validation.validatePolicy(policyData).toString();
156 assertEquals("success", responseString);
158 List<Object> attributes = new ArrayList<>();
159 policyData.setAttributes(attributes);
160 responseString = validation.validatePolicy(policyData).toString();
161 assertEquals("success", responseString);
163 attributes.add(new String("hello"));
164 responseString = validation.validatePolicy(policyData).toString();
165 assertEquals("success", responseString);
168 Map<String, String> mapAttribute = new LinkedHashMap<>();
169 attributes.add(mapAttribute);
170 responseString = validation.validatePolicy(policyData).toString();
171 assertThat(responseString).contains("Component Attributes</b>:<i> has one missing Component Attribute value");
173 mapAttribute.put("key", "value");
174 responseString = validation.validatePolicy(policyData).toString();
175 assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
178 mapAttribute.put("key", "");
179 responseString = validation.validatePolicy(policyData).toString();
180 assertEquals("<b>Attributes or Component Attributes</b>:<i>null : value has spaces or invalid characters</i>"
181 + "<br><b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
183 mapAttribute.clear();
185 responseString = validation.validatePolicy(policyData).toString();
186 mapAttribute.put("hello", "aaa");
187 responseString = validation.validatePolicy(policyData).toString();
188 assertEquals("<b>Component Attributes</b>:<i> has one missing Component Attribute key</i><br>"
189 + "<b>Component Attributes</b>:<i> has one missing Component Attribute value</i><br>",
192 policyData.setPolicyType("Config");
193 responseString = validation.validatePolicy(policyData).toString();
194 assertEquals("<b>RiskType</b>: Risk Type Should not be Empty</i><br>"
195 + "<b>RiskLevel</b>: Risk Level Should not be Empty</i><br>"
196 + "<b>Guard</b>: Guard Value Should not be Empty</i><br>", responseString);
198 policyData.setConfigPolicyType("Base");
199 responseString = validation.validatePolicy(policyData).toString();
200 assertThat(responseString).contains("has one missing Attribute key");
202 policyData.setConfigPolicyType("BRMS_Param");
203 responseString = validation.validatePolicy(policyData).toString();
204 assertThat(responseString).contains("has one missing Attribute key");
206 policyData.setConfigPolicyType("BRMS_Raw");
207 responseString = validation.validatePolicy(policyData).toString();
208 assertThat(responseString).contains("has one missing Attribute key");
210 policyData.setConfigPolicyType(null);
211 responseString = validation.validatePolicy(policyData).toString();
212 assertThat(responseString).contains("Risk Level Should not be Empty");
214 mapAttribute.clear();
215 mapAttribute.put("value", "thevalue");
216 responseString = validation.validatePolicy(policyData).toString();
217 assertThat(responseString).contains("Risk Level Should not be Empty");
219 mapAttribute.put("value", "$$$%%%%");
220 responseString = validation.validatePolicy(policyData).toString();
221 assertThat(responseString).contains("Risk Level Should not be Empty");
223 policyData.setConfigPolicyType("Base");
224 responseString = validation.validatePolicy(policyData).toString();
225 assertThat(responseString).contains("value has spaces or invalid characters");
227 policyData.setConfigPolicyType("BRMS_Param");
228 responseString = validation.validatePolicy(policyData).toString();
229 assertThat(responseString).contains("value has spaces or invalid characters");
231 policyData.setConfigPolicyType("BRMS_Raw");
232 responseString = validation.validatePolicy(policyData).toString();
233 assertThat(responseString).contains("value has spaces or invalid characters");
235 policyData.setConfigPolicyType(null);
236 policyData.setPolicyType(null);
237 responseString = validation.validatePolicy(policyData).toString();
238 assertThat(responseString).contains("value has spaces or invalid characters");
242 public void testPolicySettingsValidation() throws IOException {
243 PolicyValidation validation = new PolicyValidation();
244 PolicyRestAdapter policyData = new PolicyRestAdapter();
245 policyData.setPolicyName("ALegalPolicyName");
246 policyData.setPolicyDescription("A Valid Description");
248 String responseString = validation.validatePolicy(policyData).toString();
249 assertEquals("success", responseString);
251 policyData.setApiflag("API");
252 responseString = validation.validatePolicy(policyData).toString();
253 assertEquals("success", responseString);
255 policyData.setApiflag("NOTAPI");
256 responseString = validation.validatePolicy(policyData).toString();
257 assertEquals("success", responseString);
259 List<Object> settings = new ArrayList<>();
260 policyData.setSettings(settings);
261 responseString = validation.validatePolicy(policyData).toString();
262 assertEquals("success", responseString);
264 settings.add("hello");
265 responseString = validation.validatePolicy(policyData).toString();
266 assertEquals("success", responseString);
269 Map<String, String> mapSetting = new LinkedHashMap<>();
270 settings.add(mapSetting);
271 responseString = validation.validatePolicy(policyData).toString();
272 assertThat(responseString).contains("Settings Attributes</b>:<i> has one missing Attribute key");
274 mapSetting.put("key", "value");
275 responseString = validation.validatePolicy(policyData).toString();
276 assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString);
278 mapSetting.put("key", "");
279 responseString = validation.validatePolicy(policyData).toString();
280 assertEquals("<b>Settings Attributes</b>:<i> has one missing Attribute Value</i><br>", responseString);
283 mapSetting.put("value", "thevalue");
284 responseString = validation.validatePolicy(policyData).toString();
285 assertThat(responseString).contains("has one missing Attribute key");
287 mapSetting.put("value", "$$$%%%");
288 responseString = validation.validatePolicy(policyData).toString();
289 assertThat(responseString).contains("value has spaces or invalid characters");
293 public void testPolicyRuleAlgorithmsValidation() throws IOException {
294 PolicyValidation validation = new PolicyValidation();
295 PolicyRestAdapter policyData = new PolicyRestAdapter();
296 policyData.setPolicyName("ALegalPolicyName");
297 policyData.setPolicyDescription("A Valid Description");
299 String responseString = validation.validatePolicy(policyData).toString();
300 assertEquals("success", responseString);
302 policyData.setApiflag("API");
303 responseString = validation.validatePolicy(policyData).toString();
304 assertEquals("success", responseString);
306 policyData.setApiflag("NOTAPI");
307 responseString = validation.validatePolicy(policyData).toString();
308 assertEquals("success", responseString);
310 List<Object> ruleAlgorithmschoices = new ArrayList<>();
311 policyData.setRuleAlgorithmschoices(ruleAlgorithmschoices);
312 responseString = validation.validatePolicy(policyData).toString();
313 assertEquals("success", responseString);
315 ruleAlgorithmschoices.add("hello");
316 responseString = validation.validatePolicy(policyData).toString();
317 assertEquals("success", responseString);
318 ruleAlgorithmschoices.clear();
320 Map<String, String> mapChoice = new LinkedHashMap<>();
321 ruleAlgorithmschoices.add(mapChoice);
322 assertNull(validation.validatePolicy(policyData));
325 mapChoice.put("id", "TheID");
326 responseString = validation.validatePolicy(policyData).toString();
327 assertThat(responseString).contains("Field 1 value is not selected");
329 mapChoice.put("dynamicRuleAlgorithmField1", "Field1");
330 responseString = validation.validatePolicy(policyData).toString();
331 assertThat(responseString).contains("Field 2 value is not selected");
333 mapChoice.put("dynamicRuleAlgorithmCombo", "Combo");
334 responseString = validation.validatePolicy(policyData).toString();
335 assertThat(responseString).contains("Field 3 value is empty");
337 mapChoice.put("dynamicRuleAlgorithmField2", "Field2");
338 responseString = validation.validatePolicy(policyData).toString();
339 assertEquals("success", responseString);
341 mapChoice.put("dynamicRuleAlgorithmField2", "%%%$$$");
342 responseString = validation.validatePolicy(policyData).toString();
343 assertThat(responseString).contains("Field 3 value has special characters");
347 public void testPolicyConfigBaseValidation() throws IOException {
348 PolicyValidation validation = new PolicyValidation();
349 PolicyRestAdapter policyData = new PolicyRestAdapter();
350 policyData.setPolicyName("ALegalPolicyName");
351 policyData.setPolicyDescription("A Valid Description");
353 String responseString = validation.validatePolicy(policyData).toString();
354 assertEquals("success", responseString);
356 policyData.setApiflag("API");
357 responseString = validation.validatePolicy(policyData).toString();
358 assertEquals("success", responseString);
360 policyData.setPolicyType("Config");
361 policyData.setConfigPolicyType("Base");
362 responseString = validation.validatePolicy(policyData).toString();
363 assertThat(responseString).contains("Onap Name Should not be empty");
365 policyData.setOnapName("%%%$$$$");
366 responseString = validation.validatePolicy(policyData).toString();
367 assertThat(responseString).contains("<b>OnapName</b>:<i>The Value in Required Field");
369 policyData.setOnapName("AValidOnapName");
370 responseString = validation.validatePolicy(policyData).toString();
371 assertThat(responseString).contains("Risk Level Should not be Empty");
373 policyData.setRiskType("%%%$$$$");
374 responseString = validation.validatePolicy(policyData).toString();
375 assertThat(responseString).contains("<b>RiskType</b>:<i>The Value in Required Field");
377 policyData.setRiskType("AValidRiskType");
378 responseString = validation.validatePolicy(policyData).toString();
379 assertThat(responseString).contains("Risk Level Should not be Empty");
381 policyData.setRiskLevel("%%%$$$$");
382 responseString = validation.validatePolicy(policyData).toString();
383 assertThat(responseString).contains("<b>RiskLevel</b>:<i>The Value in Required Field");
385 policyData.setRiskLevel("AValidRiskLevel");
386 responseString = validation.validatePolicy(policyData).toString();
387 assertThat(responseString).contains("Guard Value Should not be Empty");
389 policyData.setGuard("%%%$$$$");
390 responseString = validation.validatePolicy(policyData).toString();
391 assertThat(responseString).contains("<b>Guard</b>:<i>The Value in Required Field");
393 policyData.setGuard("AValidGuard");
394 responseString = validation.validatePolicy(policyData).toString();
395 assertThat(responseString).contains("Config Name Should not be Empty");
397 policyData.setConfigName("%%%$$$$");
398 responseString = validation.validatePolicy(policyData).toString();
399 assertThat(responseString).contains("ConfigName:The Value in Required Field");
401 policyData.setConfigName("AValidConfigName");
402 responseString = validation.validatePolicy(policyData).toString();
403 assertThat(responseString).contains("Config Type Should not be Empty");
405 policyData.setConfigType("%%%$$$$");
406 responseString = validation.validatePolicy(policyData).toString();
407 assertThat(responseString).contains("ConfigType:The Value in Required Field");
409 policyData.setConfigType("AValidConfigType");
410 responseString = validation.validatePolicy(policyData).toString();
411 assertThat(responseString).contains("Config Body Should not be Empty");
413 policyData.setConfigBodyData("");
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 assertEquals("success@#", responseString);
421 policyData.setConfigType(null);
422 policyData.setConfigBodyData("ValidConfigBodyData");
423 responseString = validation.validatePolicy(policyData).toString();
424 assertThat(responseString).contains("Config Type Should not be Empty");
426 policyData.setConfigType("JSON");
427 policyData.setConfigBodyData("{");
428 responseString = validation.validatePolicy(policyData).toString();
429 assertThat(responseString).contains("Config Body: JSON Content is not valid");
431 policyData.setConfigBodyData("ValidConfigBodyData");
432 responseString = validation.validatePolicy(policyData).toString();
433 assertEquals("success@#", responseString);
435 policyData.setConfigType("XML");
436 policyData.setConfigBodyData("{");
437 responseString = validation.validatePolicy(policyData).toString();
438 assertThat(responseString).contains("Config Body: XML Content data is not valid");
440 policyData.setConfigBodyData("<tag>value</tag>");
441 responseString = validation.validatePolicy(policyData).toString();
442 assertEquals("success@#", responseString);
444 policyData.setConfigType("PROPERTIES");
445 policyData.setConfigBodyData("{");
446 responseString = validation.validatePolicy(policyData).toString();
447 assertThat(responseString).contains("Config Body: Property data is not valid");
449 policyData.setConfigBodyData("propertyName=PropertyValue");
450 responseString = validation.validatePolicy(policyData).toString();
451 assertEquals("success@#", responseString);
455 public void testPolicyConfigFirewallValidation() throws IOException {
456 PolicyValidation validation = new PolicyValidation();
457 PolicyRestAdapter policyData = new PolicyRestAdapter();
458 policyData.setPolicyName("ALegalPolicyName");
459 policyData.setPolicyDescription("A Valid Description");
461 String responseString = validation.validatePolicy(policyData).toString();
462 assertEquals("success", responseString);
464 policyData.setApiflag("API");
465 responseString = validation.validatePolicy(policyData).toString();
466 assertEquals("success", responseString);
468 // Invalid values tested in config base test
469 policyData.setOnapName("AValidOnapName");
470 policyData.setRiskType("AValidRiskType");
471 policyData.setRiskLevel("AValidRiskLevel");
472 policyData.setGuard("AValidGuard");
473 assertEquals("success", responseString);
475 policyData.setPolicyType("Config");
476 policyData.setConfigPolicyType("Firewall Config");
477 responseString = validation.validatePolicy(policyData).toString();
478 assertThat(responseString).contains("Config Name is required");
480 policyData.setConfigName("");
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("<b>ConfigName</b>:<i>The Value in Required Field");
488 policyData.setConfigName("AValidConfigName");
489 responseString = validation.validatePolicy(policyData).toString();
490 assertThat(responseString).contains("Security Zone is required");
492 policyData.setSecurityZone("");
493 responseString = validation.validatePolicy(policyData).toString();
494 assertThat(responseString).contains("Security Zone is required");
496 policyData.setSecurityZone("AValidSeurityZone");
497 responseString = validation.validatePolicy(policyData).toString();
498 assertEquals("success@#", responseString);
502 public void testPolicyConfigBRMSValidation() throws IOException {
503 PolicyValidation validation = new PolicyValidation();
504 PolicyRestAdapter policyData = new PolicyRestAdapter();
505 policyData.setPolicyName("ALegalPolicyName");
506 policyData.setPolicyDescription("A Valid Description");
508 String responseString = validation.validatePolicy(policyData).toString();
509 assertEquals("success", responseString);
511 policyData.setApiflag("API");
512 responseString = validation.validatePolicy(policyData).toString();
513 assertEquals("success", responseString);
515 // Invalid values tested in config base test
516 policyData.setOnapName("AValidOnapName");
517 policyData.setRiskType("AValidRiskType");
518 policyData.setRiskLevel("AValidRiskLevel");
519 policyData.setGuard("AValidGuard");
520 assertEquals("success", responseString);
522 policyData.setPolicyType("Config");
523 policyData.setConfigPolicyType("BRMS_Param");
524 responseString = validation.validatePolicy(policyData).toString();
525 assertThat(responseString).contains("BRMS Template is required");
527 policyData.setRuleName("");
528 responseString = validation.validatePolicy(policyData).toString();
529 assertThat(responseString).contains("BRMS Template is required");
531 policyData.setRuleName("AValidRuleName");
532 responseString = validation.validatePolicy(policyData).toString();
533 assertEquals("success@#", responseString);
534 policyData.setRuleName(null);
536 policyData.setConfigPolicyType("BRMS_Raw");
537 responseString = validation.validatePolicy(policyData).toString();
538 assertThat(responseString).contains("Raw Rule is required");
540 policyData.setConfigBodyData("");
541 responseString = validation.validatePolicy(policyData).toString();
542 assertThat(responseString).contains("Raw Rule is required");
544 policyData.setConfigBodyData("InvalidConfigBodyData");
545 responseString = validation.validatePolicy(policyData).toString();
546 assertThat(responseString).contains("expecting one of the following tokens");
548 policyData.setConfigBodyData("import org.onap.policy.test.DummyTestSomething;");
549 responseString = validation.validatePolicy(policyData).toString();
550 assertEquals("success@#", responseString);
554 public void testPolicyConfigCloseLoopPmValidation() throws IOException {
555 PolicyValidation validation = new PolicyValidation();
556 PolicyRestAdapter policyData = new PolicyRestAdapter();
557 policyData.setPolicyName("ALegalPolicyName");
558 policyData.setPolicyDescription("A Valid Description");
560 String responseString = validation.validatePolicy(policyData).toString();
561 assertEquals("success", responseString);
563 policyData.setApiflag("API");
564 responseString = validation.validatePolicy(policyData).toString();
565 assertEquals("success", responseString);
567 // Invalid values tested in config base test
568 policyData.setOnapName("AValidOnapName");
569 policyData.setRiskType("AValidRiskType");
570 policyData.setRiskLevel("AValidRiskLevel");
571 policyData.setGuard("AValidGuard");
572 assertEquals("success", responseString);
574 policyData.setPolicyType("Config");
575 policyData.setConfigPolicyType("ClosedLoop_PM");
576 responseString = validation.validatePolicy(policyData).toString();
577 assertThat(responseString).contains("ServiceType PolicyName is required");
579 Map<String, String> serviceTypePolicyName = null;
580 policyData.setServiceTypePolicyName(serviceTypePolicyName);
581 responseString = validation.validatePolicy(policyData).toString();
582 assertThat(responseString).contains("ServiceType PolicyName is required");
584 serviceTypePolicyName = new LinkedHashMap<>();
585 policyData.setServiceTypePolicyName(serviceTypePolicyName);
586 responseString = validation.validatePolicy(policyData).toString();
587 assertThat(responseString).contains("ServiceType PolicyName is required");
589 serviceTypePolicyName.put("AKey", "AValue");
590 policyData.setServiceTypePolicyName(serviceTypePolicyName);
591 responseString = validation.validatePolicy(policyData).toString();
592 assertThat(responseString).contains("ServiceType PolicyName is required");
593 serviceTypePolicyName.clear();
595 serviceTypePolicyName.put("serviceTypePolicyName", "");
596 policyData.setServiceTypePolicyName(serviceTypePolicyName);
597 responseString = validation.validatePolicy(policyData).toString();
598 assertThat(responseString).contains("ServiceType PolicyName is required");
600 serviceTypePolicyName.put("serviceTypePolicyName", "AValidserviceTypePolicyName");
601 policyData.setServiceTypePolicyName(serviceTypePolicyName);
602 responseString = validation.validatePolicy(policyData).toString();
603 assertThat(responseString).contains("Select at least one D2");
605 policyData.setJsonBody("");
606 assertNull(validation.validatePolicy(policyData));
608 policyData.setJsonBody("InvalidConfigBodyData");
609 assertNull(validation.validatePolicy(policyData));
611 policyData.setJsonBody("{}");
612 responseString = validation.validatePolicy(policyData).toString();
613 assertThat(responseString).contains("Select at least one D2");
615 policyData.setJsonBody("{\"gamma\": false}");
616 responseString = validation.validatePolicy(policyData).toString();
617 assertThat(responseString).contains("Select at least one D2");
619 policyData.setJsonBody("{\"gamma\": true}");
620 responseString = validation.validatePolicy(policyData).toString();
621 assertEquals("success@#", responseString);
623 policyData.setJsonBody("{\"mcr\": false}");
624 responseString = validation.validatePolicy(policyData).toString();
625 assertThat(responseString).contains("Select at least one D2");
627 policyData.setJsonBody("{\"mcr\": true}");
628 responseString = validation.validatePolicy(policyData).toString();
629 assertEquals("success@#", responseString);
631 policyData.setJsonBody("{\"trinity\": false}");
632 responseString = validation.validatePolicy(policyData).toString();
633 assertThat(responseString).contains("Select at least one D2");
635 policyData.setJsonBody("{\"trinity\": true}");
636 responseString = validation.validatePolicy(policyData).toString();
637 assertEquals("success@#", responseString);
639 policyData.setJsonBody("{\"vDNS\": false}");
640 responseString = validation.validatePolicy(policyData).toString();
641 assertThat(responseString).contains("Select at least one D2");
643 policyData.setJsonBody("{\"vDNS\": true}");
644 responseString = validation.validatePolicy(policyData).toString();
645 assertEquals("success@#", responseString);
647 policyData.setJsonBody("{\"vUSP\": false}");
648 responseString = validation.validatePolicy(policyData).toString();
649 assertThat(responseString).contains("Select at least one D2");
651 policyData.setJsonBody("{\"vUSP\": true}");
652 responseString = validation.validatePolicy(policyData).toString();
653 assertEquals("success@#", responseString);
655 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
656 responseString = validation.validatePolicy(policyData).toString();
657 assertEquals("success@#", responseString);
659 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}");
660 responseString = validation.validatePolicy(policyData).toString();
661 assertThat(responseString).contains("Email Address is not Valid");
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\": \"dorothy@emealdcity.oz\"}");
668 responseString = validation.validatePolicy(policyData).toString();
669 assertEquals("success@#", responseString);
671 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": null}");
672 responseString = validation.validatePolicy(policyData).toString();
673 assertEquals("success@#", responseString);
675 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"\"}");
676 responseString = validation.validatePolicy(policyData).toString();
677 assertEquals("success@#", responseString);
679 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"$$$%%%\"}");
680 responseString = validation.validatePolicy(policyData).toString();
681 assertThat(responseString).contains("The Value in Required Field");
683 policyData.setJsonBody("{\"trinity\": true, \"geoLink\": \"AValidGeoLink\"}");
684 responseString = validation.validatePolicy(policyData).toString();
685 assertEquals("success@#", responseString);
687 policyData.setJsonBody("{\"trinity\": true, \"attributes\": null}");
688 responseString = validation.validatePolicy(policyData).toString();
689 assertEquals("success@#", responseString);
691 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {}}");
692 responseString = validation.validatePolicy(policyData).toString();
693 assertEquals("success@#", responseString);
695 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"av0\"}}");
696 responseString = validation.validatePolicy(policyData).toString();
697 assertEquals("success@#", responseString);
699 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"an0\":\"$$$%%%\"}}");
700 responseString = validation.validatePolicy(policyData).toString();
701 assertThat(responseString).contains("value has spaces or invalid characters");
703 policyData.setJsonBody("{\"trinity\": true, \"attributes\": {\"Message\":\"$$$%%%\"}}");
704 responseString = validation.validatePolicy(policyData).toString();
705 assertEquals("success@#", responseString);
709 public void testPolicyConfigCloseLoopFaultValidation() throws IOException {
710 PolicyValidation validation = new PolicyValidation();
711 PolicyRestAdapter policyData = new PolicyRestAdapter();
712 policyData.setPolicyName("ALegalPolicyName");
713 policyData.setPolicyDescription("A Valid Description");
715 String responseString = validation.validatePolicy(policyData).toString();
716 assertEquals("success", responseString);
718 policyData.setApiflag("API");
719 responseString = validation.validatePolicy(policyData).toString();
720 assertEquals("success", responseString);
722 // Invalid values tested in config base test
723 policyData.setOnapName("AValidOnapName");
724 policyData.setRiskType("AValidRiskType");
725 policyData.setRiskLevel("AValidRiskLevel");
726 policyData.setGuard("AValidGuard");
727 assertEquals("success", responseString);
729 policyData.setPolicyType("Config");
730 policyData.setConfigPolicyType("ClosedLoop_Fault");
731 responseString = validation.validatePolicy(policyData).toString();
732 assertThat(responseString).contains("Select at least one D2");
734 policyData.setJsonBody("");
735 assertNull(validation.validatePolicy(policyData));
737 policyData.setJsonBody("InvalidConfigBodyData");
738 assertNull(validation.validatePolicy(policyData));
740 policyData.setJsonBody("{}");
741 responseString = validation.validatePolicy(policyData).toString();
742 assertThat(responseString).contains("There were no conditions provided in configBody json");
744 policyData.setJsonBody("{\"conditions\": null}");
745 responseString = validation.validatePolicy(policyData).toString();
746 assertThat(responseString).contains("There were no conditions provided in configBody json");
748 policyData.setJsonBody("{\"conditions\": \"\"}");
749 responseString = validation.validatePolicy(policyData).toString();
750 assertThat(responseString).contains("Select At least one Condition");
752 policyData.setJsonBody("{\"conditions\": \"AValidCondition\"}");
753 assertNull(validation.validatePolicy(policyData));
755 policyData.setApiflag("NOAPI");
757 policyData.setJsonBody("");
758 assertNull(validation.validatePolicy(policyData));
760 policyData.setJsonBody("InvalidConfigBodyData");
761 assertNull(validation.validatePolicy(policyData));
763 ClosedLoopFaultTrapDatas trapDatas = new ClosedLoopFaultTrapDatas();
764 policyData.setTrapDatas(trapDatas);
766 ClosedLoopFaultTrapDatas faultDatas = new ClosedLoopFaultTrapDatas();
767 policyData.setFaultDatas(faultDatas);
769 policyData.setJsonBody("{}");
770 assertThat(responseString).contains("Select At least one Condition");
772 List<Object> trap1 = new ArrayList<>();
773 trapDatas.setTrap1(trap1);
774 responseString = validation.validatePolicy(policyData).toString();
775 assertThat(responseString).contains("Trigger Clear TimeOut is required");
777 policyData.setClearTimeOut("AValidClearTimeout");
778 responseString = validation.validatePolicy(policyData).toString();
779 assertThat(responseString).contains("Trap Max Age is required");
781 policyData.setTrapMaxAge("AValidTrapMaxAge");
782 responseString = validation.validatePolicy(policyData).toString();
783 assertThat(responseString).contains("Select at least one D2");
785 trapDatas.setTrap1(null);
786 responseString = validation.validatePolicy(policyData).toString();
787 assertThat(responseString).contains("Select at least one D2");
789 faultDatas.setTrap1(null);
790 responseString = validation.validatePolicy(policyData).toString();
791 assertThat(responseString).contains("Select at least one D2");
793 faultDatas.setTrap1(trap1);
794 responseString = validation.validatePolicy(policyData).toString();
795 assertThat(responseString).contains("Fault Clear TimeOut is required when");
797 policyData.setVerificationclearTimeOut("AValidVerificationClearTimeout");
798 responseString = validation.validatePolicy(policyData).toString();
799 assertThat(responseString).contains("Select at least one D2");
801 policyData.setJsonBody("{\"gamma\": false}");
802 responseString = validation.validatePolicy(policyData).toString();
803 assertThat(responseString).contains("Select at least one D2");
805 policyData.setJsonBody("{\"gamma\": true}");
806 responseString = validation.validatePolicy(policyData).toString();
807 assertThat(responseString).contains("vPRO Actions is required");
809 policyData.setJsonBody("{\"mcr\": false}");
810 responseString = validation.validatePolicy(policyData).toString();
811 assertThat(responseString).contains("Select at least one D2");
813 policyData.setJsonBody("{\"mcr\": true}");
814 responseString = validation.validatePolicy(policyData).toString();
815 assertThat(responseString).contains("vPRO Actions is required");
817 policyData.setJsonBody("{\"trinity\": false}");
818 responseString = validation.validatePolicy(policyData).toString();
819 assertThat(responseString).contains("Select at least one D2");
821 policyData.setJsonBody("{\"trinity\": true}");
822 responseString = validation.validatePolicy(policyData).toString();
823 assertThat(responseString).contains("vPRO Actions is required");
825 policyData.setJsonBody("{\"vDNS\": false}");
826 responseString = validation.validatePolicy(policyData).toString();
827 assertThat(responseString).contains("Select at least one D2");
829 policyData.setJsonBody("{\"vDNS\": true}");
830 responseString = validation.validatePolicy(policyData).toString();
831 assertThat(responseString).contains("vPRO Actions is required");
833 policyData.setJsonBody("{\"vUSP\": false}");
834 responseString = validation.validatePolicy(policyData).toString();
835 assertThat(responseString).contains("Select at least one D2");
837 policyData.setJsonBody("{\"vUSP\": true}");
838 responseString = validation.validatePolicy(policyData).toString();
839 assertThat(responseString).contains("vPRO Actions is required");
841 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": null}");
842 responseString = validation.validatePolicy(policyData).toString();
843 assertThat(responseString).contains("vPRO Actions is required");
845 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"\"}");
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("Email Address is not Valid");
853 policyData.setJsonBody("{\"trinity\": true, \"emailAddress\": \"dorothy@emealdcity.oz\"}");
854 responseString = validation.validatePolicy(policyData).toString();
855 assertThat(responseString).contains("vPRO Actions is required");
857 policyData.setJsonBody("{\"trinity\": true, \"actions\": null}");
858 responseString = validation.validatePolicy(policyData).toString();
859 assertThat(responseString).contains("vPRO Actions is required");
861 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"\"}");
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("Policy Status is required");
868 assertThat(responseString).contains("Vnf Type is required");
870 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\"}");
871 responseString = validation.validatePolicy(policyData).toString();
872 assertThat(responseString).contains("Policy Status is required");
874 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": null}");
875 responseString = validation.validatePolicy(policyData).toString();
876 assertThat(responseString).contains("Policy Status is required");
878 policyData.setJsonBody("{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"\"}");
879 responseString = validation.validatePolicy(policyData).toString();
880 assertThat(responseString).contains("Policy Status is required");
882 policyData.setJsonBody(
883 "{\"trinity\": true, \"actions\": \"ValidActions\", \"closedLoopPolicyStatus\": \"$$$%%%\"}");
884 responseString = validation.validatePolicy(policyData).toString();
885 assertThat(responseString).contains("Select At least one Condition");
888 policyData.setJsonBody("{"
889 + "\"trinity\": true,"
890 + "\"actions\": \"ValidActions\","
891 + "\"closedLoopPolicyStatus\": \"AValidStatus\""
894 responseString = validation.validatePolicy(policyData).toString();
895 assertThat(responseString).contains("Select At least one Condition");
898 policyData.setJsonBody("{"
899 + "\"trinity\": true,"
900 + "\"actions\": \"ValidActions\","
901 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
902 + "\"conditions\": null"
905 responseString = validation.validatePolicy(policyData).toString();
906 assertThat(responseString).contains("Select At least one Condition");
909 policyData.setJsonBody("{"
910 + "\"trinity\": true,"
911 + "\"actions\": \"ValidActions\","
912 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
913 + "\"conditions\": \"SEND\""
916 responseString = validation.validatePolicy(policyData).toString();
917 assertThat(responseString).contains("Aging Window is required");
920 policyData.setJsonBody("{"
921 + "\"trinity\": true,"
922 + "\"actions\": \"ValidActions\","
923 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
924 + "\"conditions\": \"SEND\","
925 + "\"geoLink\": null"
928 responseString = validation.validatePolicy(policyData).toString();
929 assertThat(responseString).contains("Aging Window is required");
932 policyData.setJsonBody("{"
933 + "\"trinity\": true,"
934 + "\"actions\": \"ValidActions\","
935 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
936 + "\"conditions\": \"SEND\","
937 + "\"geoLink\": \"\""
940 responseString = validation.validatePolicy(policyData).toString();
941 assertThat(responseString).contains("Aging Window is required");
944 policyData.setJsonBody("{"
945 + "\"trinity\": true,"
946 + "\"actions\": \"ValidActions\","
947 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
948 + "\"conditions\": \"SEND\","
949 + "\"geoLink\": \"%%%$$$\""
952 responseString = validation.validatePolicy(policyData).toString();
953 assertThat(responseString).contains("GeoLink</b>:<i>The Value in Required Field");
956 policyData.setJsonBody("{"
957 + "\"trinity\": true,"
958 + "\"actions\": \"ValidActions\","
959 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
960 + "\"conditions\": \"SEND\","
961 + "\"geoLink\": \"AValidGeoLink\""
964 responseString = validation.validatePolicy(policyData).toString();
965 assertThat(responseString).contains("Aging Window is required");
968 policyData.setJsonBody("{"
969 + "\"trinity\": true,"
970 + "\"actions\": \"ValidActions\","
971 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
972 + "\"conditions\": \"SEND\","
973 + "\"agingWindow\": -1"
976 responseString = validation.validatePolicy(policyData).toString();
977 assertThat(responseString).contains("Time Interval is required");
980 policyData.setJsonBody("{"
981 + "\"trinity\": true,"
982 + "\"actions\": \"ValidActions\","
983 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
984 + "\"conditions\": \"SEND\","
985 + "\"agingWindow\": -1,"
986 + "\"timeInterval\": -1"
989 responseString = validation.validatePolicy(policyData).toString();
990 assertThat(responseString).contains("Number of Retries is required");
993 policyData.setJsonBody("{"
994 + "\"trinity\": true,"
995 + "\"actions\": \"ValidActions\","
996 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
997 + "\"conditions\": \"SEND\","
998 + "\"agingWindow\": -1,"
999 + "\"timeInterval\": -1,"
1003 responseString = validation.validatePolicy(policyData).toString();
1004 assertThat(responseString).contains("APP-C Timeout is required");
1007 policyData.setJsonBody("{"
1008 + "\"trinity\": true,"
1009 + "\"actions\": \"ValidActions\","
1010 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1011 + "\"conditions\": \"SEND\","
1012 + "\"agingWindow\": -1,"
1013 + "\"timeInterval\": -1,"
1015 + "\"timeOutvPRO\": -1"
1018 responseString = validation.validatePolicy(policyData).toString();
1019 assertThat(responseString).contains("TimeOutRuby is required");
1022 policyData.setJsonBody("{"
1023 + "\"trinity\": true,"
1024 + "\"actions\": \"ValidActions\","
1025 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1026 + "\"conditions\": \"SEND\","
1027 + "\"agingWindow\": -1,"
1028 + "\"timeInterval\": -1,"
1030 + "\"timeOutvPRO\": -1,"
1031 + "\"timeOutRuby\": -1"
1034 responseString = validation.validatePolicy(policyData).toString();
1035 assertThat(responseString).contains("Vnf Type is required");
1038 policyData.setJsonBody("{"
1039 + "\"trinity\": true,"
1040 + "\"actions\": \"ValidActions\","
1041 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1042 + "\"conditions\": \"SEND\","
1043 + "\"agingWindow\": -1,"
1044 + "\"timeInterval\": -1,"
1046 + "\"timeOutvPRO\": -1,"
1047 + "\"timeOutRuby\": -1,"
1048 + "\"vnfType\": null"
1051 responseString = validation.validatePolicy(policyData).toString();
1052 assertThat(responseString).contains("Vnf Type is required");
1055 policyData.setJsonBody("{"
1056 + "\"trinity\": true,"
1057 + "\"actions\": \"ValidActions\","
1058 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1059 + "\"conditions\": \"SEND\","
1060 + "\"agingWindow\": -1,"
1061 + "\"timeInterval\": -1,"
1063 + "\"timeOutvPRO\": -1,"
1064 + "\"timeOutRuby\": -1,"
1065 + "\"vnfType\": \"\""
1068 responseString = validation.validatePolicy(policyData).toString();
1069 assertThat(responseString).contains("Vnf Type is required");
1072 policyData.setJsonBody("{"
1073 + "\"trinity\": true,"
1074 + "\"actions\": \"ValidActions\","
1075 + "\"closedLoopPolicyStatus\": \"AValidStatus\","
1076 + "\"conditions\": \"SEND\","
1077 + "\"agingWindow\": -1,"
1078 + "\"timeInterval\": -1,"
1080 + "\"timeOutvPRO\": -1,"
1081 + "\"timeOutRuby\": -1,"
1082 + "\"vnfType\": \"AValid VNF Type\""
1085 responseString = validation.validatePolicy(policyData).toString();
1086 assertEquals("success@#", responseString);