2 * ============LICENSE_START=======================================================
3 * policy-yaml unit test
4 * ================================================================================
5 * Copyright (C) 2017-2020 AT&T Intellectual Property. All rights reserved.
6 * Modifications Copyright (C) 2019-2020 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.controlloop.policy;
24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
25 import static org.junit.Assert.assertEquals;
26 import static org.junit.Assert.assertFalse;
27 import static org.junit.Assert.assertNotNull;
28 import static org.junit.Assert.assertNull;
29 import static org.junit.Assert.assertTrue;
32 import java.io.FileInputStream;
33 import java.io.InputStream;
34 import java.util.UUID;
36 import org.junit.Ignore;
37 import org.junit.Test;
38 import org.onap.aai.domain.yang.Pnf;
39 import org.onap.policy.controlloop.policy.builder.BuilderException;
40 import org.onap.policy.controlloop.policy.builder.ControlLoopPolicyBuilder;
41 import org.onap.policy.controlloop.policy.builder.Message;
42 import org.onap.policy.controlloop.policy.builder.MessageLevel;
43 import org.onap.policy.controlloop.policy.builder.Results;
44 import org.onap.policy.sdc.Resource;
45 import org.onap.policy.sdc.ResourceType;
46 import org.onap.policy.sdc.Service;
47 import org.yaml.snakeyaml.Yaml;
48 import org.yaml.snakeyaml.constructor.Constructor;
49 import org.yaml.snakeyaml.error.YAMLException;
51 public class ControlLoopPolicyBuilderTest {
53 private static final String RESOURCE1 = "resource1";
54 private static final String TRIGGER_RESTART = "Upon getting the trigger event, restart the VM";
55 private static final String UNKNOWN_POLICY = "Unknown policy ";
56 private static final String RESTART = "Restart";
57 private static final String RESTART_VM = "Restart the VM";
58 private static final String REBUILD = "Rebuild";
59 private static final String REBUILD_VM = "Rebuild VM";
60 private static final String REBUILD_RESTART = "If the restart fails, rebuild it.";
63 public void testControlLoop() throws BuilderException {
65 // Create a builder for our policy
67 ControlLoopPolicyBuilder builder =
68 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
72 Service scp = new Service("vSCP");
73 Service usp = new Service("vUSP");
74 Service trinity = new Service("Trinity");
75 builder = builder.addService(scp, usp, trinity);
76 assertTrue(builder.getControlLoop().getServices().size() == 3);
78 // Test remove services
80 builder = builder.removeService(scp);
81 assertTrue(builder.getControlLoop().getServices().size() == 2);
82 builder = builder.removeAllServices();
83 assertTrue(builder.getControlLoop().getServices().isEmpty());
87 Resource cts = new Resource("vCTS", ResourceType.VF);
88 Resource com = new Resource("vCTS", ResourceType.VF);
89 Resource rar = new Resource("vCTS", ResourceType.VF);
90 builder = builder.addResource(cts, com, rar);
91 assertTrue(builder.getControlLoop().getResources().size() == 3);
93 // Test remove resources
95 builder = builder.removeResource(cts);
96 assertTrue(builder.getControlLoop().getResources().size() == 2);
97 builder = builder.removeAllResources();
98 assertTrue(builder.getControlLoop().getResources().isEmpty());
102 public void testAddNullService() throws BuilderException {
103 ControlLoopPolicyBuilder builder =
104 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
106 assertThatThrownBy(() -> {
107 builder.addService((Service) null);
108 }).isInstanceOf(BuilderException.class).hasMessage("Service must not be null");
112 public void testAddInvalidService() throws BuilderException {
113 ControlLoopPolicyBuilder builder =
114 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
116 assertThatThrownBy(() -> {
117 builder.addService(new Service());
118 }).isInstanceOf(BuilderException.class)
119 .hasMessage("Invalid service - need either a serviceUUID or serviceName");
123 public void testAddServiceWithUuid() throws BuilderException {
124 ControlLoopPolicyBuilder builder =
125 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
126 UUID uuid = UUID.randomUUID();
127 Service serviceWithUuid = new Service(uuid);
128 builder.addService(serviceWithUuid);
129 assertTrue(builder.getControlLoop().getServices().size() == 1);
133 public void testAddNullResource() throws BuilderException {
134 ControlLoopPolicyBuilder builder =
135 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
137 assertThatThrownBy(() -> {
138 builder.addResource((Resource) null);
139 }).isInstanceOf(BuilderException.class).hasMessage("Resource must not be null");
143 public void testAddInvalidResource() throws BuilderException {
144 ControlLoopPolicyBuilder builder =
145 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
147 assertThatThrownBy(() -> {
148 builder.addResource(new Resource());
149 }).isInstanceOf(BuilderException.class)
150 .hasMessage("Invalid resource - need either resourceUUID or resourceName");
154 public void testAddAndRemoveResourceWithUuid() throws BuilderException {
155 ControlLoopPolicyBuilder builder =
156 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
157 UUID uuid = UUID.randomUUID();
158 Resource resourceWithUuid = new Resource(uuid);
159 builder.addResource(resourceWithUuid);
160 assertTrue(builder.getControlLoop().getResources().size() == 1);
162 builder.removeResource(resourceWithUuid);
163 assertTrue(builder.getControlLoop().getResources().isEmpty());
167 public void testRemoveNullResource() throws BuilderException {
168 ControlLoopPolicyBuilder builder =
169 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
170 Resource resource = new Resource(RESOURCE1, ResourceType.VF);
171 builder.addResource(resource);
173 assertThatThrownBy(() -> {
174 builder.removeResource((Resource) null);
175 }).isInstanceOf(BuilderException.class).hasMessage("Resource must not be null");
179 public void testRemoveResourceNoExistingResources() throws BuilderException {
180 ControlLoopPolicyBuilder builder =
181 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
183 assertThatThrownBy(() -> {
184 builder.removeResource(new Resource(RESOURCE1, ResourceType.VF));
185 }).isInstanceOf(BuilderException.class).hasMessage("No existing resources to remove");
189 public void testRemoveInvalidResource() throws BuilderException {
190 ControlLoopPolicyBuilder builder =
191 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
192 Resource resource = new Resource(RESOURCE1, ResourceType.VF);
193 builder.addResource(resource);
195 assertThatThrownBy(() -> {
196 builder.removeResource(new Resource());
197 }).isInstanceOf(BuilderException.class)
198 .hasMessage("Invalid resource - need either a resourceUUID or resourceName");
202 public void testRemoveUnknownResource() throws BuilderException {
203 ControlLoopPolicyBuilder builder =
204 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
205 Resource resource = new Resource(RESOURCE1, ResourceType.VF);
206 builder.addResource(resource);
207 final String unknownResourceName = "reource2";
209 assertThatThrownBy(() -> {
210 builder.removeResource(new Resource(unknownResourceName, ResourceType.VF));
211 }).isInstanceOf(BuilderException.class).hasMessage("Unknown resource " + unknownResourceName);
215 public void testControlLoopWithInitialResourceAndServices() throws BuilderException {
216 Resource cts = new Resource("vCTS", ResourceType.VF);
217 Service scp = new Service("vSCP");
218 Service usp = new Service("vUSP");
219 ControlLoopPolicyBuilder builder =
220 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, cts, scp, usp);
221 assertTrue(builder.getControlLoop().getResources().size() == 1);
222 assertTrue(builder.getControlLoop().getServices().size() == 2);
226 public void testControlLoopWithInitialResourcesAndService() throws BuilderException {
227 Resource cts = new Resource("vCTS", ResourceType.VF);
228 Resource com = new Resource("vCTS", ResourceType.VF);
229 Service scp = new Service("vSCP");
230 ControlLoopPolicyBuilder builder =
231 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, scp, cts, com);
232 assertTrue(builder.getControlLoop().getServices().size() == 1);
233 assertTrue(builder.getControlLoop().getResources().size() == 2);
238 // I'VE MARKED THIS TEST CASE AS IGNORE BECAUSE THE TEST CASE FAILS
239 // This test case fails because builder.getControlLoop() returns an instance of ControlLoop
241 // the ControlLoop(ControlLoop controlLoop) constructor.
242 // This constructor does not copy the value of pnf into the newly created object
243 // On the face of it, this looks like a bug, but perhaps there is a reason for this
244 // PLEASE ADVISE IF THE BEHAVIOUR IS INCORRECT OR THE TEST CASE IS INVALID
245 public void testControlLoopForPnf() throws BuilderException {
247 // pnf.setPnfType(PnfType.ENODEB);
248 ControlLoopPolicyBuilder builder =
249 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, pnf);
250 assertEquals(pnf, builder.getControlLoop().getPnf());
253 assertNull(builder.getControlLoop().getPnf());
258 // Fails for the same reason as the above test case
259 public void testSetAndRemovePnf() throws BuilderException {
260 ControlLoopPolicyBuilder builder =
261 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
262 assertNull(builder.getControlLoop().getPnf());
265 // pnf.setPnfType(PnfType.ENODEB);
267 assertEquals(pnf, builder.getControlLoop().getPnf());
270 assertNull(builder.getControlLoop().getPnf());
274 public void testSetNullPnf() throws BuilderException {
275 ControlLoopPolicyBuilder builder =
276 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
278 assertThatThrownBy(() -> {
279 builder.setPnf(null);
280 }).isInstanceOf(BuilderException.class).hasMessage("PNF must not be null");
284 public void testSetInvalidPnf() throws BuilderException {
285 ControlLoopPolicyBuilder builder =
286 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
288 assertThatThrownBy(() -> {
289 builder.setPnf(new Pnf());
290 }).isInstanceOf(BuilderException.class).hasMessage("Invalid PNF - need either pnfName or pnfType");
294 public void testSetAbatement() throws BuilderException {
295 ControlLoopPolicyBuilder builder =
296 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
297 assertFalse(builder.getControlLoop().getAbatement());
298 builder = builder.setAbatement(true);
299 assertTrue(builder.getControlLoop().getAbatement());
303 public void testSetNullAbatement() throws BuilderException {
304 assertThatThrownBy(() -> {
305 ControlLoopPolicyBuilder builder =
306 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
308 builder = builder.setAbatement(null);
309 }).isInstanceOf(BuilderException.class).hasMessage("abatement must not be null");
313 public void testTimeout() throws BuilderException {
315 // Create a builder for our policy
317 ControlLoopPolicyBuilder builder =
318 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
322 assertTrue(builder.getControlLoop().getTimeout() == 2400);
323 builder = builder.setTimeout(800);
324 assertTrue(builder.getControlLoop().getTimeout() == 800);
326 // Test calculateTimeout
329 Policy trigger = builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
331 .description(TRIGGER_RESTART)
332 .actor("APPC").target(new Target(TargetType.VM))
339 @SuppressWarnings("unused")
340 Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
341 PolicyParam.builder()
343 .description("If the restart fails, rebuild it").actor("APPC")
344 .target(new Target(TargetType.VM))
351 PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
352 assertEquals(Integer.valueOf(300 + 600), builder.calculateTimeout());
357 public void testTriggerPolicyMethods() throws BuilderException {
358 ControlLoopPolicyBuilder builder =
359 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
363 assertTrue(builder.isOpenLoop());
365 // Test set initial trigger policy
368 Policy triggerPolicy1 = builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
370 .description(TRIGGER_RESTART)
372 .target(new Target(TargetType.VM))
378 assertFalse(builder.isOpenLoop());
379 assertEquals(builder.getControlLoop().getTrigger_policy(), triggerPolicy1.getId());
381 // Set trigger policy to a new policy
383 @SuppressWarnings("unused")
384 Policy triggerPolicy2 = builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
385 .name("Rebuild the VM")
386 .description("Upon getting the trigger event, rebuild the VM").actor("APPC")
387 .target(new Target(TargetType.VM))
395 // Test set trigger policy to another existing policy
397 @SuppressWarnings("unused")
398 ControlLoop cl = builder.setExistingTriggerPolicy(triggerPolicy1.getId());
399 assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
401 // Test get trigger policy
403 assertTrue(builder.getTriggerPolicy().equals(triggerPolicy1));
407 public void testSetTriggerPolicyNullPolicyId() throws BuilderException {
408 ControlLoopPolicyBuilder builder =
409 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
411 assertThatThrownBy(() -> {
412 builder.setExistingTriggerPolicy(null);
413 }).isInstanceOf(BuilderException.class).hasMessage("Id must not be null");
417 public void testSetTriggerPolicyNoPoliciesExist() throws BuilderException {
418 ControlLoopPolicyBuilder builder =
419 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
420 final String unknownPolicyId = "100";
422 assertThatThrownBy(() -> {
423 builder.setExistingTriggerPolicy(unknownPolicyId);
424 }).isInstanceOf(BuilderException.class).hasMessage(UNKNOWN_POLICY + unknownPolicyId);
428 public void testSetTriggerPolicyUnknownPolicy() throws BuilderException {
429 ControlLoopPolicyBuilder builder =
430 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
432 builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
434 .description(TRIGGER_RESTART)
436 .target(new Target(TargetType.VM))
443 final String unknownPolicyId = "100";
445 assertThatThrownBy(() -> {
446 builder.setExistingTriggerPolicy(unknownPolicyId);
447 }).isInstanceOf(BuilderException.class).hasMessage(UNKNOWN_POLICY + unknownPolicyId);
451 public void testAddRemovePolicies() throws BuilderException {
452 ControlLoopPolicyBuilder builder =
453 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
455 Policy triggerPolicy = builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
457 .description(TRIGGER_RESTART)
459 .target(new Target(TargetType.VM))
466 // Test create a policy and chain it to the results of trigger policy
468 Policy onRestartFailurePolicy1 = builder.setPolicyForPolicyResult(PolicyParam.builder()
470 .description(REBUILD_RESTART)
472 .target(new Target(TargetType.VM))
473 .recipe(REBUILD).payload(null)
476 .id(triggerPolicy.getId())
478 PolicyResult.FAILURE, PolicyResult.FAILURE_EXCEPTION, PolicyResult.FAILURE_RETRIES,
479 PolicyResult.FAILURE_TIMEOUT, PolicyResult.FAILURE_GUARD);
481 assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy1.getId()));
482 assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy1.getId()));
483 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy1.getId()));
484 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy1.getId()));
485 assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy1.getId()));
488 // Test create a policy and chain it to the results of trigger policy success
490 Policy onSuccessPolicy1 = builder.setPolicyForPolicyResult(PolicyParam.builder()
491 .name("Do something")
492 .description("If the restart succeeds, do something else.")
494 .target(new Target(TargetType.VM))
495 .recipe("SomethingElse")
499 .id(triggerPolicy.getId())
501 PolicyResult.SUCCESS);
504 assertTrue(builder.getTriggerPolicy().getSuccess().equals(onSuccessPolicy1.getId()));
507 // Test remove policy
509 boolean removed = builder.removePolicy(onRestartFailurePolicy1.getId());
511 assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
513 builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
515 builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
516 assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString()));
518 // Create another policy and chain it to the results of trigger policy
521 final Policy onRestartFailurePolicy2 = builder.setPolicyForPolicyResult(
522 PolicyParam.builder()
524 .description(REBUILD_RESTART)
526 .target(new Target(TargetType.VM))
531 .id(triggerPolicy.getId())
533 PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
536 // Test reset policy results
538 triggerPolicy = builder.resetPolicyResults(triggerPolicy.getId());
539 assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
541 builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
543 builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
545 // Test set the policy results to an existing operational policy
547 Policy onRestartFailurePolicy3 = builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(),
548 triggerPolicy.getId(), PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
549 assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy3.getId()));
550 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy3.getId()));
551 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy3.getId()));
553 // Test set the policy result for success to an existing operational policy
555 Policy onRestartFailurePolicy4 = builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(),
556 triggerPolicy.getId(), PolicyResult.FAILURE, PolicyResult.FAILURE_EXCEPTION, PolicyResult.FAILURE_GUARD,
557 PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT, PolicyResult.SUCCESS);
558 assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy4.getId()));
559 assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy4.getId()));
560 assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy4.getId()));
561 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy4.getId()));
562 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy4.getId()));
563 assertTrue(builder.getTriggerPolicy().getSuccess().equals(onRestartFailurePolicy4.getId()));
566 // Test remove all existing operational policies
568 builder = builder.removeAllPolicies();
569 assertTrue(builder.getControlLoop().getTrigger_policy().equals(FinalResult.FINAL_OPENLOOP.toString()));
573 public void testAddToUnknownPolicy() throws BuilderException {
574 ControlLoopPolicyBuilder builder =
575 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
576 final String policyId = "100";
578 assertThatThrownBy(() -> {
580 builder.setPolicyForPolicyResult(
581 PolicyParam.builder()
583 .description(REBUILD_RESTART)
585 .target(new Target(TargetType.VM))
592 PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT,
593 PolicyResult.FAILURE_GUARD);
595 }).isInstanceOf(BuilderException.class).hasMessage(UNKNOWN_POLICY + policyId);
600 public void testAddExistingPolicyToUnknownPolicy() throws BuilderException {
601 ControlLoopPolicyBuilder builder =
602 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
604 Policy triggerPolicy = builder.setTriggerPolicy(PolicyParam.builder()
605 .id(UUID.randomUUID().toString())
607 .description(TRIGGER_RESTART)
609 .target(new Target(TargetType.VM))
616 Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(PolicyParam.builder()
618 .description(REBUILD_RESTART)
620 .target(new Target(TargetType.VM))
625 .id(triggerPolicy.getId())
627 PolicyResult.FAILURE);
630 final String unknownPolicyId = "100";
632 assertThatThrownBy(() -> {
633 builder.setPolicyForPolicyResult(onRestartFailurePolicy.getId(), unknownPolicyId, PolicyResult.FAILURE);
634 }).isInstanceOf(BuilderException.class).hasMessage(unknownPolicyId + " does not exist");
639 public void testAddUnknownExistingPolicyToPolicy() throws BuilderException {
640 ControlLoopPolicyBuilder builder =
641 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
643 Policy triggerPolicy = builder.setTriggerPolicy(PolicyParam.builder()
644 .id(UUID.randomUUID().toString())
646 .description(TRIGGER_RESTART)
648 .target(new Target(TargetType.VM))
656 final String unknownPolicyId = "100";
658 assertThatThrownBy(() -> {
659 builder.setPolicyForPolicyResult(unknownPolicyId, triggerPolicy.getId(), PolicyResult.FAILURE);
660 }).isInstanceOf(BuilderException.class).hasMessage("Operational policy " + unknownPolicyId + " does not exist");
665 public void testAddOperationsAccumulateParams() throws BuilderException {
666 ControlLoopPolicyBuilder builder =
667 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
669 Policy triggerPolicy =
670 builder.setTriggerPolicy(PolicyParam.builder()
671 .id(UUID.randomUUID().toString())
672 .name("Restart the eNodeB")
673 .description("Upon getting the trigger event, restart the eNodeB")
674 .actor("RANController")
675 .target(new Target(TargetType.PNF))
683 // Add the operationsAccumulateParams
686 builder.addOperationsAccumulateParams(triggerPolicy.getId(), new OperationsAccumulateParams("15m", 5));
687 assertNotNull(builder.getTriggerPolicy().getOperationsAccumulateParams());
688 assertEquals("15m", builder.getTriggerPolicy().getOperationsAccumulateParams().getPeriod());
689 assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getLimit() == 5);
693 public void testBuildSpecification() throws BuilderException {
695 // Create the builder
697 ControlLoopPolicyBuilder builder =
698 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 800);
700 // Set the first invalid trigger policy
703 final Policy policy1 = builder.setTriggerPolicy(
704 PolicyParam.builder()
705 .id(UUID.randomUUID().toString())
707 .description(TRIGGER_RESTART)
715 Results results = builder.buildSpecification();
718 // Check that ERRORs are in results for invalid policy arguments
720 boolean invalidActor = false;
721 boolean invalidRecipe = false;
722 boolean invalidTarget = false;
723 for (Message m : results.getMessages()) {
724 if ("Policy actor is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
727 if ("Policy recipe is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
728 invalidRecipe = true;
730 if ("Policy target is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
731 invalidTarget = true;
735 assertTrue(invalidActor);
736 assertTrue(invalidRecipe);
737 assertTrue(invalidTarget);
739 // Remove the invalid policy
741 // @SuppressWarnings("unused")
742 boolean removed = builder.removePolicy(policy1.getId());
744 assertTrue(builder.getTriggerPolicy() == null);
746 // Set a valid trigger policy
749 Policy policy1a = builder.setTriggerPolicy(PolicyParam.builder()
750 .id(UUID.randomUUID().toString())
752 .description(REBUILD_RESTART)
754 .target(new Target(TargetType.VM))
761 // Set a second valid trigger policy
763 final Policy policy2 = builder.setTriggerPolicy(PolicyParam.builder()
764 .id(UUID.randomUUID().toString())
766 .description(TRIGGER_RESTART)
768 .target(new Target(TargetType.VM))
776 // Now, we have policy1 unreachable
778 results = builder.buildSpecification();
779 boolean unreachable = false;
780 for (Message m : results.getMessages()) {
781 if (m.getMessage().equals("Policy " + policy1a.getId() + " is not reachable.")
782 && m.getLevel() == MessageLevel.WARNING) {
787 assertTrue(unreachable);
789 // Set policy1a for the failure results of policy2
791 policy1a = builder.setPolicyForPolicyResult(policy1a.getId(), policy2.getId(), PolicyResult.FAILURE,
792 PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
793 results = builder.buildSpecification();
794 boolean invalidTimeout = false;
795 for (Message m : results.getMessages()) {
796 if ("controlLoop overall timeout is less than the sum of operational policy timeouts."
797 .equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
798 invalidTimeout = true;
802 assertTrue(invalidTimeout);
804 // Remove policy2 (revert controlLoop back to open loop)
806 removed = builder.removePolicy(policy2.getId());
808 // ControlLoop is open loop now, but it still has policies (policy1)
810 results = builder.buildSpecification();
812 for (Message m : results.getMessages()) {
813 if ("Open Loop policy contains policies. The policies will never be invoked.".equals(m.getMessage())
814 && m.getLevel() == MessageLevel.WARNING) {
819 assertTrue(unreachable);
823 public void test1() throws Exception {
824 this.test("src/test/resources/v1.0.0/policy_Test.yaml");
828 public void testEvilYaml() throws Exception {
829 try (InputStream is = new FileInputStream(new File("src/test/resources/v1.0.0/test_evil.yaml"))) {
831 // Attempt to read the yaml into our Java Object
833 Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
834 assertThatThrownBy(() -> yaml.load(is)).isInstanceOf(YAMLException.class);
839 * Does the actual test.
841 * @param testFile input file
842 * @throws Exception if an error occurs
844 public void test(String testFile) throws Exception {
845 try (InputStream is = new FileInputStream(new File(testFile))) {
847 // Read the yaml into our Java Object
849 Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
850 Object obj = yaml.load(is);
852 assertTrue(obj instanceof ControlLoopPolicy);
853 ControlLoopPolicy policyTobuild = (ControlLoopPolicy) obj;
855 // Now we're going to try to use the builder to build this.
857 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(
858 policyTobuild.getControlLoop().getControlLoopName(), policyTobuild.getControlLoop().getTimeout());
862 if (policyTobuild.getControlLoop().getServices() != null) {
863 builder = builder.addService(policyTobuild.getControlLoop().getServices()
864 .toArray(new Service[policyTobuild.getControlLoop().getServices().size()]));
869 if (policyTobuild.getControlLoop().getResources() != null) {
870 builder = builder.addResource(policyTobuild.getControlLoop().getResources()
871 .toArray(new Resource[policyTobuild.getControlLoop().getResources().size()]));
876 if (policyTobuild.getControlLoop().getPnf() != null) {
877 builder = builder.setPnf(policyTobuild.getControlLoop().getPnf());
880 // Add the policies and be sure to set the trigger policy
882 if (policyTobuild.getPolicies() != null) {
883 setTriggerPolicies(policyTobuild, builder);
886 // Question : how to change policy ID and results by using builder ??
888 @SuppressWarnings("unused")
889 Results results = builder.buildSpecification();
894 private void setTriggerPolicies(ControlLoopPolicy policyTobuild, ControlLoopPolicyBuilder builder)
895 throws BuilderException {
896 for (Policy policy : policyTobuild.getPolicies()) {
897 if (policy.getId() == policyTobuild.getControlLoop().getTrigger_policy()) {
899 builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
900 .name(policy.getName())
901 .description(policy.getDescription())
902 .actor(policy.getActor())
903 .target(policy.getTarget())
904 .recipe(policy.getRecipe())
906 .retries(policy.getRetry())
907 .timeout(policy.getTimeout())