2 * ============LICENSE_START=======================================================
3 * policy-yaml unit test
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.policy.controlloop.policy;
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertFalse;
25 import static org.junit.Assert.assertNotNull;
26 import static org.junit.Assert.assertNull;
27 import static org.junit.Assert.assertTrue;
28 import static org.junit.Assert.fail;
31 import java.io.FileInputStream;
32 import java.io.FileNotFoundException;
33 import java.io.IOException;
34 import java.io.InputStream;
35 import java.util.UUID;
36 import org.junit.Ignore;
37 import org.junit.Rule;
38 import org.junit.Test;
39 import org.junit.rules.ExpectedException;
40 import org.onap.policy.aai.PNF;
41 import org.onap.policy.aai.PNFType;
42 import org.onap.policy.controlloop.policy.builder.BuilderException;
43 import org.onap.policy.controlloop.policy.builder.ControlLoopPolicyBuilder;
44 import org.onap.policy.controlloop.policy.builder.Message;
45 import org.onap.policy.controlloop.policy.builder.MessageLevel;
46 import org.onap.policy.controlloop.policy.builder.Results;
47 import org.onap.policy.sdc.Resource;
48 import org.onap.policy.sdc.ResourceType;
49 import org.onap.policy.sdc.Service;
50 import org.yaml.snakeyaml.Yaml;
51 import org.yaml.snakeyaml.constructor.Constructor;
52 import org.yaml.snakeyaml.error.YAMLException;
55 public class ControlLoopPolicyBuilderTest {
58 public ExpectedException expectedException = ExpectedException.none();
61 public void testControlLoop() {
64 // Create a builder for our policy
66 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
70 Service vSCP = new Service("vSCP");
71 Service vUSP = new Service("vUSP");
72 Service vTrinity = new Service("Trinity");
73 builder = builder.addService(vSCP, vUSP, vTrinity);
74 assertTrue(builder.getControlLoop().getServices().size() == 3);
76 // Test remove services
78 builder = builder.removeService(vSCP);
79 assertTrue(builder.getControlLoop().getServices().size() == 2);
80 builder = builder.removeAllServices();
81 assertTrue(builder.getControlLoop().getServices().size() == 0);
85 Resource vCTS = new Resource("vCTS", ResourceType.VF);
86 Resource vCOM = new Resource("vCTS", ResourceType.VF);
87 Resource vRAR = new Resource("vCTS", ResourceType.VF);
88 builder = builder.addResource(vCTS, vCOM, vRAR);
89 assertTrue(builder.getControlLoop().getResources().size() == 3);
91 // Test remove resources
93 builder = builder.removeResource(vCTS);
94 assertTrue(builder.getControlLoop().getResources().size() == 2);
95 builder = builder.removeAllResources();
96 assertTrue(builder.getControlLoop().getResources().size() == 0);
97 } catch (BuilderException e) {
103 public void testAddNullService() throws BuilderException {
104 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
105 expectedException.expect(BuilderException.class);
106 expectedException.expectMessage("Service must not be null");
107 builder.addService((Service)null);
111 public void testAddInvalidService() throws BuilderException {
112 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
113 expectedException.expect(BuilderException.class);
114 expectedException.expectMessage("Invalid service - need either a serviceUUID or serviceName");
115 builder.addService(new Service());
119 public void testAddServiceWithUUID() throws BuilderException {
120 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
121 UUID uuid = UUID.randomUUID();
122 Service serviceWithUUID = new Service(uuid);
123 builder.addService(serviceWithUUID);
124 assertTrue(builder.getControlLoop().getServices().size() == 1);
128 public void testAddNullResource() throws BuilderException {
129 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
130 expectedException.expect(BuilderException.class);
131 expectedException.expectMessage("Resource must not be null");
132 builder.addResource((Resource)null);
137 public void testAddInvalidResource() throws BuilderException {
138 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
139 expectedException.expect(BuilderException.class);
140 expectedException.expectMessage("Invalid resource - need either resourceUUID or resourceName");
141 builder.addResource(new Resource());
145 public void testAddAndRemoveResourceWithUUID() throws BuilderException {
146 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
147 UUID uuid = UUID.randomUUID();
148 Resource resourceWithUUID = new Resource(uuid);
149 builder.addResource(resourceWithUUID);
150 assertTrue(builder.getControlLoop().getResources().size() == 1);
152 builder.removeResource(resourceWithUUID);
153 assertTrue(builder.getControlLoop().getResources().size() == 0);
157 public void testRemoveNullResource() throws BuilderException {
158 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
159 Resource resource = new Resource("resource1", ResourceType.VF);
160 builder.addResource(resource);
161 expectedException.expect(BuilderException.class);
162 expectedException.expectMessage("Resource must not be null");
163 builder.removeResource((Resource)null);
167 public void testRemoveResourceNoExistingResources() throws BuilderException {
168 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
169 expectedException.expect(BuilderException.class);
170 expectedException.expectMessage("No existing resources to remove");
171 builder.removeResource(new Resource("resource1", ResourceType.VF));
175 public void testRemoveInvalidResource() throws BuilderException {
176 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
177 Resource resource = new Resource("resource1", ResourceType.VF);
178 builder.addResource(resource);
179 expectedException.expect(BuilderException.class);
180 expectedException.expectMessage("Invalid resource - need either a resourceUUID or resourceName");
181 builder.removeResource(new Resource());
185 public void testRemoveUnknownResource() throws BuilderException {
186 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
187 Resource resource = new Resource("resource1", ResourceType.VF);
188 builder.addResource(resource);
189 final String unknownResourceName = "reource2";
190 expectedException.expect(BuilderException.class);
191 expectedException.expectMessage("Unknown resource " + unknownResourceName);
192 builder.removeResource(new Resource(unknownResourceName, ResourceType.VF));
196 public void testControlLoopWithInitialResourceAndServices() {
198 Resource vCTS = new Resource("vCTS", ResourceType.VF);
199 Service vSCP = new Service("vSCP");
200 Service vUSP = new Service("vUSP");
201 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, vCTS, vSCP, vUSP);
202 assertTrue(builder.getControlLoop().getResources().size() == 1);
203 assertTrue(builder.getControlLoop().getServices().size() == 2);
204 } catch (BuilderException e) {
205 fail(e.getMessage());
210 public void testControlLoopWithInitialResourcesAndService() {
212 Resource vCTS = new Resource("vCTS", ResourceType.VF);
213 Resource vCOM = new Resource("vCTS", ResourceType.VF);
214 Service vSCP = new Service("vSCP");
215 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, vSCP, vCTS, vCOM);
216 assertTrue(builder.getControlLoop().getServices().size() == 1);
217 assertTrue(builder.getControlLoop().getResources().size() == 2);
218 } catch (BuilderException e) {
219 fail(e.getMessage());
225 // I'VE MARKED THIS TEST CASE AS IGNORE BECAUSE THE TEST CASE FAILS
226 // This test case fails because builder.getControlLoop() returns an instance of ControlLoop copied using
227 // the ControlLoop(ControlLoop controlLoop) constructor.
228 // This constructor does not copy the value of pnf into the newly created object
229 // On the face of it, this looks like a bug, but perhaps there is a reason for this
230 // PLEASE ADVISE IF THE BEHAVIOUR IS INCORRECT OR THE TEST CASE IS INVALID
231 public void testControlLoopForPnf() {
234 pnf.setPNFType(PNFType.ENODEB);
235 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, pnf);
236 assertEquals(pnf, builder.getControlLoop().getPnf());
239 assertNull(builder.getControlLoop().getPnf());
240 } catch (BuilderException e) {
241 fail(e.getMessage());
247 // Fails for the same reason as the above test case
248 public void testSetAndRemovePnf() throws BuilderException {
249 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
250 assertNull(builder.getControlLoop().getPnf());
253 pnf.setPNFType(PNFType.ENODEB);
255 assertEquals(pnf, builder.getControlLoop().getPnf());
258 assertNull(builder.getControlLoop().getPnf());
262 public void testSetNullPnf() throws BuilderException {
263 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
264 expectedException.expect(BuilderException.class);
265 expectedException.expectMessage("PNF must not be null");
266 builder.setPNF(null);
270 public void testSetInvalidPnf() throws BuilderException {
271 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
272 expectedException.expect(BuilderException.class);
273 expectedException.expectMessage("Invalid PNF - need either pnfName or pnfType");
274 builder.setPNF(new PNF());
278 public void testSetAbatement() throws BuilderException {
279 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
280 assertFalse(builder.getControlLoop().getAbatement());
281 builder = builder.setAbatement(true);
282 assertTrue(builder.getControlLoop().getAbatement());
286 public void testSetNullAbatement() throws BuilderException {
287 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
288 expectedException.expect(BuilderException.class);
289 expectedException.expectMessage("abatement must not be null");
290 builder = builder.setAbatement(null);
294 public void testTimeout() {
297 // Create a builder for our policy
299 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
303 assertTrue(builder.getControlLoop().getTimeout() == 2400);
304 builder = builder.setTimeout(800);
305 assertTrue(builder.getControlLoop().getTimeout() == 800);
307 // Test calculateTimeout
309 Policy trigger = builder.setTriggerPolicy(
311 "Upon getting the trigger event, restart the VM",
313 new Target(TargetType.VM),
318 @SuppressWarnings("unused")
319 Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
321 "If the restart fails, rebuild it",
323 new Target(TargetType.VM),
329 PolicyResult.FAILURE,
330 PolicyResult.FAILURE_RETRIES,
331 PolicyResult.FAILURE_TIMEOUT);
332 assertTrue(builder.calculateTimeout().equals(new Integer(300 + 600)));
334 } catch (BuilderException e) {
335 fail(e.getMessage());
340 public void testTriggerPolicyMethods() {
342 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
346 assertTrue(builder.isOpenLoop());
348 // Test set initial trigger policy
350 Policy triggerPolicy1 = builder.setTriggerPolicy(
352 "Upon getting the trigger event, restart the VM",
354 new Target(TargetType.VM),
359 assertTrue(builder.isOpenLoop() == false);
360 assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
362 // Set trigger policy to a new policy
364 @SuppressWarnings("unused")
365 Policy triggerPolicy2 = builder.setTriggerPolicy(
367 "Upon getting the trigger event, rebuild the VM",
369 new Target(TargetType.VM),
375 // Test set trigger policy to another existing policy
377 @SuppressWarnings("unused")
378 ControlLoop cl = builder.setTriggerPolicy(triggerPolicy1.getId());
379 assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
381 // Test get trigger policy
383 assertTrue(builder.getTriggerPolicy().equals(triggerPolicy1));
385 } catch (BuilderException e) {
386 fail(e.getMessage());
391 public void testSetTriggerPolicyNullPolicyId() throws BuilderException {
392 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
393 expectedException.expect(BuilderException.class);
394 expectedException.expectMessage("Id must not be null");
395 builder.setTriggerPolicy(null);
399 public void testSetTriggerPolicyNoPoliciesExist() throws BuilderException {
400 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
401 final String unknownPolicyId = "100";
402 expectedException.expect(BuilderException.class);
403 expectedException.expectMessage("Unknown policy " + unknownPolicyId);
404 builder.setTriggerPolicy(unknownPolicyId);
408 public void testSetTriggerPolicyUnknownPolicy() throws BuilderException {
409 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
410 builder.setTriggerPolicy(
412 "Upon getting the trigger event, restart the VM",
414 new Target(TargetType.VM),
419 final String unknownPolicyId = "100";
420 expectedException.expect(BuilderException.class);
421 expectedException.expectMessage("Unknown policy " + unknownPolicyId);
422 builder.setTriggerPolicy(unknownPolicyId);
426 public void testAddRemovePolicies() {
428 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
429 Policy triggerPolicy = builder.setTriggerPolicy(
431 "Upon getting the trigger event, restart the VM",
433 new Target(TargetType.VM),
439 // Test create a policy and chain it to the results of trigger policy
441 Policy onRestartFailurePolicy1 = builder.setPolicyForPolicyResult(
443 "If the restart fails, rebuild it.",
445 new Target(TargetType.VM),
450 triggerPolicy.getId(),
451 PolicyResult.FAILURE,
452 PolicyResult.FAILURE_EXCEPTION,
453 PolicyResult.FAILURE_RETRIES,
454 PolicyResult.FAILURE_TIMEOUT,
455 PolicyResult.FAILURE_GUARD);
457 assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy1.getId()));
458 assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy1.getId()));
459 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy1.getId()));
460 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy1.getId()));
461 assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy1.getId()));
464 // Test create a policy and chain it to the results of trigger policy success
466 Policy onSuccessPolicy1 = builder.setPolicyForPolicyResult(
468 "If the restart succeeds, do something else.",
470 new Target(TargetType.VM),
475 triggerPolicy.getId(),
476 PolicyResult.SUCCESS);
478 assertTrue(builder.getTriggerPolicy().getSuccess().equals(onSuccessPolicy1.getId()));
481 // Test remove policy
483 boolean removed = builder.removePolicy(onRestartFailurePolicy1.getId());
485 assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
486 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
487 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
488 assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString()));
490 // Create another policy and chain it to the results of trigger policy
492 Policy onRestartFailurePolicy2 = builder.setPolicyForPolicyResult(
494 "If the restart fails, rebuild it.",
496 new Target(TargetType.VM),
501 triggerPolicy.getId(),
502 PolicyResult.FAILURE,
503 PolicyResult.FAILURE_RETRIES,
504 PolicyResult.FAILURE_TIMEOUT);
506 // Test reset policy results
508 triggerPolicy = builder.resetPolicyResults(triggerPolicy.getId());
509 assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
510 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
511 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
513 // Test set the policy results to an existing operational policy
515 onRestartFailurePolicy2 = builder.setPolicyForPolicyResult(
516 onRestartFailurePolicy2.getId(),
517 triggerPolicy.getId(),
518 PolicyResult.FAILURE,
519 PolicyResult.FAILURE_RETRIES,
520 PolicyResult.FAILURE_TIMEOUT);
521 assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy2.getId()));
522 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy2.getId()));
523 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy2.getId()));
525 // Test set the policy result for success to an existing operational policy
527 onRestartFailurePolicy2 = builder.setPolicyForPolicyResult(
528 onRestartFailurePolicy2.getId(),
529 triggerPolicy.getId(),
530 PolicyResult.FAILURE,
531 PolicyResult.FAILURE_EXCEPTION,
532 PolicyResult.FAILURE_GUARD,
533 PolicyResult.FAILURE_RETRIES,
534 PolicyResult.FAILURE_TIMEOUT,
535 PolicyResult.SUCCESS);
536 assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy2.getId()));
537 assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy2.getId()));
538 assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy2.getId()));
539 assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy2.getId()));
540 assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy2.getId()));
541 assertTrue(builder.getTriggerPolicy().getSuccess().equals(onRestartFailurePolicy2.getId()));
544 // Test remove all existing operational policies
546 builder = builder.removeAllPolicies();
547 assertTrue(builder.getControlLoop().getTrigger_policy().equals(FinalResult.FINAL_OPENLOOP.toString()));
549 } catch (BuilderException e) {
550 fail(e.getMessage());
555 public void testAddToUnknownPolicy() throws BuilderException {
556 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
557 final String policyId = "100";
558 expectedException.expect(BuilderException.class);
559 expectedException.expectMessage("Unknown policy " + policyId);
561 builder.setPolicyForPolicyResult(
563 "If the restart fails, rebuild it.",
565 new Target(TargetType.VM),
571 PolicyResult.FAILURE,
572 PolicyResult.FAILURE_RETRIES,
573 PolicyResult.FAILURE_TIMEOUT,
574 PolicyResult.FAILURE_GUARD);
578 public void testAddExistingPolicyToUnknownPolicy() throws BuilderException {
579 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
580 Policy triggerPolicy = builder.setTriggerPolicy(
582 "Upon getting the trigger event, restart the VM",
584 new Target(TargetType.VM),
591 Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
593 "If the restart fails, rebuild it.",
595 new Target(TargetType.VM),
600 triggerPolicy.getId(),
601 PolicyResult.FAILURE);
603 final String unknownPolicyId = "100";
604 expectedException.expect(BuilderException.class);
605 expectedException.expectMessage(unknownPolicyId + " does not exist");
607 builder.setPolicyForPolicyResult(
608 onRestartFailurePolicy.getId(),
610 PolicyResult.FAILURE);
614 public void testAddUnknownExistingPolicyToPolicy() throws BuilderException {
615 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
616 Policy triggerPolicy = builder.setTriggerPolicy(
618 "Upon getting the trigger event, restart the VM",
620 new Target(TargetType.VM),
626 final String unknownPolicyId = "100";
627 expectedException.expect(BuilderException.class);
628 expectedException.expectMessage("Operational policy " + unknownPolicyId + " does not exist");
630 builder.setPolicyForPolicyResult(
632 triggerPolicy.getId(),
633 PolicyResult.FAILURE);
637 public void testAddOperationsAccumulateParams() {
639 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
640 Policy triggerPolicy = builder.setTriggerPolicy(
641 "Restart the eNodeB",
642 "Upon getting the trigger event, restart the eNodeB",
644 new Target(TargetType.PNF),
650 // Add the operationsAccumulateParams
652 triggerPolicy = builder.addOperationsAccumulateParams(triggerPolicy.getId(), new OperationsAccumulateParams("15m", 5));
653 assertNotNull(builder.getTriggerPolicy().getOperationsAccumulateParams());
654 assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getPeriod().equals("15m"));
655 assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getLimit() == 5);
657 } catch (BuilderException e) {
658 fail(e.getMessage());
664 public void testBuildSpecification() {
667 // Create the builder
669 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 800);
671 // Set the first invalid trigger policy
673 Policy policy1 = builder.setTriggerPolicy(
675 "Upon getting the trigger event, restart the VM",
682 Results results = builder.buildSpecification();
684 // Check that ERRORs are in results for invalid policy arguments
686 boolean invalid_actor = false;
687 boolean invalid_recipe = false;
688 boolean invalid_target = false;
689 for (Message m : results.getMessages()) {
690 if (m.getMessage().equals("Policy actor is null") && m.getLevel() == MessageLevel.ERROR) {
691 invalid_actor = true;
693 if (m.getMessage().equals("Policy recipe is invalid") && m.getLevel() == MessageLevel.ERROR) {
694 invalid_recipe = true;
696 if (m.getMessage().equals("Policy target is null") && m.getLevel() == MessageLevel.ERROR) {
697 invalid_target = true;
701 assertTrue(invalid_actor);
702 assertTrue(invalid_recipe);
703 assertTrue(invalid_target);
705 // Remove the invalid policy
707 //@SuppressWarnings("unused")
708 boolean removed = builder.removePolicy(policy1.getId());
710 assertTrue(builder.getTriggerPolicy() == null);
712 // Set a valid trigger policy
714 policy1 = builder.setTriggerPolicy(
716 "If the restart fails, rebuild it.",
718 new Target(TargetType.VM),
724 // Set a second valid trigger policy
726 Policy policy2 = builder.setTriggerPolicy(
728 "Upon getting the trigger event, restart the VM",
730 new Target(TargetType.VM),
736 // Now, we have policy1 unreachable
738 results = builder.buildSpecification();
739 boolean unreachable = false;
740 for (Message m : results.getMessages()) {
741 if (m.getMessage().equals("Policy " + policy1.getId() + " is not reachable.") && m.getLevel() == MessageLevel.WARNING) {
746 assertTrue(unreachable);
748 // Set policy1 for the failure results of policy2
750 policy1 = builder.setPolicyForPolicyResult(
753 PolicyResult.FAILURE,
754 PolicyResult.FAILURE_RETRIES,
755 PolicyResult.FAILURE_TIMEOUT);
756 results = builder.buildSpecification();
757 boolean invalid_timeout = false;
758 for (Message m : results.getMessages()) {
759 if (m.getMessage().equals("controlLoop overall timeout is less than the sum of operational policy timeouts.") && m.getLevel() == MessageLevel.ERROR) {
760 invalid_timeout = true;
764 assertTrue(invalid_timeout);
766 // Remove policy2 (revert controlLoop back to open loop)
768 removed = builder.removePolicy(policy2.getId());
770 // ControlLoop is open loop now, but it still has policies (policy1)
772 results = builder.buildSpecification();
774 for (Message m : results.getMessages()) {
775 if (m.getMessage().equals("Open Loop policy contains policies. The policies will never be invoked.") && m.getLevel() == MessageLevel.WARNING) {
780 assertTrue(unreachable);
782 } catch (BuilderException e) {
783 fail(e.getMessage());
790 this.test("src/test/resources/v1.0.0/policy_Test.yaml");
794 public void testEvilYaml() {
795 try (InputStream is = new FileInputStream(new File("src/test/resources/v1.0.0/test_evil.yaml"))) {
797 // Read the yaml into our Java Object
799 Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
801 } catch (FileNotFoundException e) {
802 fail(e.getLocalizedMessage());
803 } catch (IOException e) {
804 fail(e.getLocalizedMessage());
805 } catch (YAMLException e) {
812 public void test(String testFile) {
813 try (InputStream is = new FileInputStream(new File(testFile))) {
815 // Read the yaml into our Java Object
817 Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
818 Object obj = yaml.load(is);
820 assertTrue(obj instanceof ControlLoopPolicy);
821 ControlLoopPolicy policyTobuild = (ControlLoopPolicy) obj;
823 // Now we're going to try to use the builder to build this.
825 ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(
826 policyTobuild.getControlLoop().getControlLoopName(),
827 policyTobuild.getControlLoop().getTimeout());
831 if (policyTobuild.getControlLoop().getServices() != null) {
832 builder = builder.addService(policyTobuild.getControlLoop().getServices().toArray(new Service[policyTobuild.getControlLoop().getServices().size()]));
837 if (policyTobuild.getControlLoop().getResources() != null) {
838 builder = builder.addResource(policyTobuild.getControlLoop().getResources().toArray(new Resource[policyTobuild.getControlLoop().getResources().size()]));
843 if (policyTobuild.getControlLoop().getPnf() != null) {
844 builder = builder.setPNF(policyTobuild.getControlLoop().getPnf());
847 // Add the policies and be sure to set the trigger policy
849 if (policyTobuild.getPolicies() != null) {
850 for (Policy policy : policyTobuild.getPolicies()) {
851 if (policy.getId() == policyTobuild.getControlLoop().getTrigger_policy()) {
852 builder.setTriggerPolicy(policy.getName(), policy.getDescription(), policy.getActor(), policy.getTarget(), policy.getRecipe(), null, policy.getRetry(), policy.getTimeout());
857 // Question : how to change policy ID and results by using builder ??
859 @SuppressWarnings("unused")
860 Results results = builder.buildSpecification();
862 } catch (FileNotFoundException e) {
863 fail(e.getLocalizedMessage());
864 } catch (IOException e) {
865 fail(e.getLocalizedMessage());
866 } catch (BuilderException e) {
867 fail(e.getLocalizedMessage());