models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopPolicyBuilderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * policy-yaml unit test
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2019 Nordix Foundation.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.controlloop.policy;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.junit.Assert.assertNull;
  28 import static org.junit.Assert.assertTrue;
  29 import static org.junit.Assert.fail;
  30
  31 import java.io.File;
  32 import java.io.FileInputStream;
  33 import java.io.FileNotFoundException;
  34 import java.io.IOException;
  35 import java.io.InputStream;
  36 import java.util.UUID;
  37
  38 import org.junit.Ignore;
  39 import org.junit.Rule;
  40 import org.junit.Test;
  41 import org.junit.rules.ExpectedException;
  42 import org.onap.policy.aai.Pnf;
  43 import org.onap.policy.aai.PnfType;
  44 import org.onap.policy.controlloop.policy.builder.BuilderException;
  45 import org.onap.policy.controlloop.policy.builder.ControlLoopPolicyBuilder;
  46 import org.onap.policy.controlloop.policy.builder.Message;
  47 import org.onap.policy.controlloop.policy.builder.MessageLevel;
  48 import org.onap.policy.controlloop.policy.builder.Results;
  49 import org.onap.policy.sdc.Resource;
  50 import org.onap.policy.sdc.ResourceType;
  51 import org.onap.policy.sdc.Service;
  52 import org.yaml.snakeyaml.Yaml;
  53 import org.yaml.snakeyaml.constructor.Constructor;
  54 import org.yaml.snakeyaml.error.YAMLException;
  55
  56
  57 public class ControlLoopPolicyBuilderTest {
  58
  59     @Rule
  60     public ExpectedException expectedException = ExpectedException.none();
  61
  62     @Test
  63     public void testControlLoop() {
  64         try {
  65             //
  66             // Create a builder for our policy
  67             //
  68             ControlLoopPolicyBuilder builder =
  69                     ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
  70             //
  71             // Test add services
  72             //
  73             Service scp = new Service("vSCP");
  74             Service usp = new Service("vUSP");
  75             Service trinity = new Service("Trinity");
  76             builder = builder.addService(scp, usp, trinity);
  77             assertTrue(builder.getControlLoop().getServices().size() == 3);
  78             //
  79             // Test remove services
  80             //
  81             builder = builder.removeService(scp);
  82             assertTrue(builder.getControlLoop().getServices().size() == 2);
  83             builder = builder.removeAllServices();
  84             assertTrue(builder.getControlLoop().getServices().size() == 0);
  85             //
  86             // Test add resources
  87             //
  88             Resource cts = new Resource("vCTS", ResourceType.VF);
  89             Resource com = new Resource("vCTS", ResourceType.VF);
  90             Resource rar = new Resource("vCTS", ResourceType.VF);
  91             builder = builder.addResource(cts, com, rar);
  92             assertTrue(builder.getControlLoop().getResources().size() == 3);
  93             //
  94             // Test remove resources
  95             //
  96             builder = builder.removeResource(cts);
  97             assertTrue(builder.getControlLoop().getResources().size() == 2);
  98             builder = builder.removeAllResources();
  99             assertTrue(builder.getControlLoop().getResources().size() == 0);
 100         } catch (BuilderException e) {
 101             fail(e.getMessage());
 102         }
 103     }
 104
 105     @Test
 106     public void testAddNullService() throws BuilderException {
 107         ControlLoopPolicyBuilder builder =
 108                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 109         expectedException.expect(BuilderException.class);
 110         expectedException.expectMessage("Service must not be null");
 111         builder.addService((Service) null);
 112     }
 113
 114     @Test
 115     public void testAddInvalidService() throws BuilderException {
 116         ControlLoopPolicyBuilder builder =
 117                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 118         expectedException.expect(BuilderException.class);
 119         expectedException.expectMessage("Invalid service - need either a serviceUUID or serviceName");
 120         builder.addService(new Service());
 121     }
 122
 123     @Test
 124     public void testAddServiceWithUuid() throws BuilderException {
 125         ControlLoopPolicyBuilder builder =
 126                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 127         UUID uuid = UUID.randomUUID();
 128         Service serviceWithUuid = new Service(uuid);
 129         builder.addService(serviceWithUuid);
 130         assertTrue(builder.getControlLoop().getServices().size() == 1);
 131     }
 132
 133     @Test
 134     public void testAddNullResource() throws BuilderException {
 135         ControlLoopPolicyBuilder builder =
 136                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 137         expectedException.expect(BuilderException.class);
 138         expectedException.expectMessage("Resource must not be null");
 139         builder.addResource((Resource) null);
 140     }
 141
 142
 143     @Test
 144     public void testAddInvalidResource() throws BuilderException {
 145         ControlLoopPolicyBuilder builder =
 146                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 147         expectedException.expect(BuilderException.class);
 148         expectedException.expectMessage("Invalid resource - need either resourceUUID or resourceName");
 149         builder.addResource(new Resource());
 150     }
 151
 152     @Test
 153     public void testAddAndRemoveResourceWithUuid() throws BuilderException {
 154         ControlLoopPolicyBuilder builder =
 155                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 156         UUID uuid = UUID.randomUUID();
 157         Resource resourceWithUuid = new Resource(uuid);
 158         builder.addResource(resourceWithUuid);
 159         assertTrue(builder.getControlLoop().getResources().size() == 1);
 160
 161         builder.removeResource(resourceWithUuid);
 162         assertTrue(builder.getControlLoop().getResources().size() == 0);
 163     }
 164
 165     @Test
 166     public void testRemoveNullResource() throws BuilderException {
 167         ControlLoopPolicyBuilder builder =
 168                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 169         Resource resource = new Resource("resource1", ResourceType.VF);
 170         builder.addResource(resource);
 171         expectedException.expect(BuilderException.class);
 172         expectedException.expectMessage("Resource must not be null");
 173         builder.removeResource((Resource) null);
 174     }
 175
 176     @Test
 177     public void testRemoveResourceNoExistingResources() throws BuilderException {
 178         ControlLoopPolicyBuilder builder =
 179                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 180         expectedException.expect(BuilderException.class);
 181         expectedException.expectMessage("No existing resources to remove");
 182         builder.removeResource(new Resource("resource1", ResourceType.VF));
 183     }
 184
 185     @Test
 186     public void testRemoveInvalidResource() throws BuilderException {
 187         ControlLoopPolicyBuilder builder =
 188                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 189         Resource resource = new Resource("resource1", ResourceType.VF);
 190         builder.addResource(resource);
 191         expectedException.expect(BuilderException.class);
 192         expectedException.expectMessage("Invalid resource - need either a resourceUUID or resourceName");
 193         builder.removeResource(new Resource());
 194     }
 195
 196     @Test
 197     public void testRemoveUnknownResource() throws BuilderException {
 198         ControlLoopPolicyBuilder builder =
 199                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 200         Resource resource = new Resource("resource1", ResourceType.VF);
 201         builder.addResource(resource);
 202         final String unknownResourceName = "reource2";
 203         expectedException.expect(BuilderException.class);
 204         expectedException.expectMessage("Unknown resource " + unknownResourceName);
 205         builder.removeResource(new Resource(unknownResourceName, ResourceType.VF));
 206     }
 207
 208     @Test
 209     public void testControlLoopWithInitialResourceAndServices() {
 210         try {
 211             Resource cts = new Resource("vCTS", ResourceType.VF);
 212             Service scp = new Service("vSCP");
 213             Service usp = new Service("vUSP");
 214             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory
 215                     .buildControlLoop(UUID.randomUUID().toString(), 2400, cts, scp, usp);
 216             assertTrue(builder.getControlLoop().getResources().size() == 1);
 217             assertTrue(builder.getControlLoop().getServices().size() == 2);
 218         } catch (BuilderException e) {
 219             fail(e.getMessage());
 220         }
 221     }
 222
 223     @Test
 224     public void testControlLoopWithInitialResourcesAndService() {
 225         try {
 226             Resource cts = new Resource("vCTS", ResourceType.VF);
 227             Resource com = new Resource("vCTS", ResourceType.VF);
 228             Service scp = new Service("vSCP");
 229             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory
 230                     .buildControlLoop(UUID.randomUUID().toString(), 2400, scp, cts, com);
 231             assertTrue(builder.getControlLoop().getServices().size() == 1);
 232             assertTrue(builder.getControlLoop().getResources().size() == 2);
 233         } catch (BuilderException e) {
 234             fail(e.getMessage());
 235         }
 236     }
 237
 238     @Test
 239     @Ignore
 240     // I'VE MARKED THIS TEST CASE AS IGNORE BECAUSE THE TEST CASE FAILS
 241     // This test case fails because builder.getControlLoop() returns an instance of ControlLoop
 242     // copied using
 243     // the ControlLoop(ControlLoop controlLoop) constructor.
 244     // This constructor does not copy the value of pnf into the newly created object
 245     // On the face of it, this looks like a bug, but perhaps there is a reason for this
 246     // PLEASE ADVISE IF THE BEHAVIOUR IS INCORRECT OR THE TEST CASE IS INVALID
 247     public void testControlLoopForPnf() {
 248         try {
 249             Pnf pnf = new Pnf();
 250             pnf.setPnfType(PnfType.ENODEB);
 251             ControlLoopPolicyBuilder builder =
 252                     ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, pnf);
 253             assertEquals(pnf, builder.getControlLoop().getPnf());
 254
 255             builder.removePNF();
 256             assertNull(builder.getControlLoop().getPnf());
 257         } catch (BuilderException e) {
 258             fail(e.getMessage());
 259         }
 260     }
 261
 262     @Test
 263     @Ignore
 264     // Fails for the same reason as the above test case
 265     public void testSetAndRemovePnf() throws BuilderException {
 266         ControlLoopPolicyBuilder builder =
 267                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 268         assertNull(builder.getControlLoop().getPnf());
 269
 270         Pnf pnf = new Pnf();
 271         pnf.setPnfType(PnfType.ENODEB);
 272         builder.setPNF(pnf);
 273         assertEquals(pnf, builder.getControlLoop().getPnf());
 274
 275         builder.removePNF();
 276         assertNull(builder.getControlLoop().getPnf());
 277     }
 278
 279     @Test
 280     public void testSetNullPnf() throws BuilderException {
 281         ControlLoopPolicyBuilder builder =
 282                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 283         expectedException.expect(BuilderException.class);
 284         expectedException.expectMessage("PNF must not be null");
 285         builder.setPNF(null);
 286     }
 287
 288     @Test
 289     public void testSetInvalidPnf() throws BuilderException {
 290         ControlLoopPolicyBuilder builder =
 291                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 292         expectedException.expect(BuilderException.class);
 293         expectedException.expectMessage("Invalid PNF - need either pnfName or pnfType");
 294         builder.setPNF(new Pnf());
 295     }
 296
 297     @Test
 298     public void testSetAbatement() throws BuilderException {
 299         ControlLoopPolicyBuilder builder =
 300                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 301         assertFalse(builder.getControlLoop().getAbatement());
 302         builder = builder.setAbatement(true);
 303         assertTrue(builder.getControlLoop().getAbatement());
 304     }
 305
 306     @Test
 307     public void testSetNullAbatement() throws BuilderException {
 308         ControlLoopPolicyBuilder builder =
 309                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 310         expectedException.expect(BuilderException.class);
 311         expectedException.expectMessage("abatement must not be null");
 312         builder = builder.setAbatement(null);
 313     }
 314
 315     @Test
 316     public void testTimeout() {
 317         try {
 318             //
 319             // Create a builder for our policy
 320             //
 321             ControlLoopPolicyBuilder builder =
 322                     ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 323             //
 324             // Test setTimeout
 325             //
 326             assertTrue(builder.getControlLoop().getTimeout() == 2400);
 327             builder = builder.setTimeout(800);
 328             assertTrue(builder.getControlLoop().getTimeout() == 800);
 329             //
 330             // Test calculateTimeout
 331             //
 332             Policy trigger =
 333                     builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
 334                             .name("Restart the VM")
 335                             .description("Upon getting the trigger event, restart the VM")
 336                             .actor("APPC")
 337                             .target(new Target(TargetType.VM))
 338                             .recipe("Restart")
 339                             .payload(null)
 340                             .retries(2)
 341                             .timeout(300).build());
 342             @SuppressWarnings("unused")
 343             Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
 344                     PolicyParam.builder()
 345                             .name("Rebuild VM")
 346                             .description("If the restart fails, rebuild it")
 347                             .actor("APPC")
 348                             .target(new Target(TargetType.VM))
 349                             .recipe("Rebuild")
 350                             .payload(null)
 351                             .retries(1)
 352                             .timeout(600)
 353                             .id(trigger.getId()).build(),
 354                             PolicyResult.FAILURE,
 355                             PolicyResult.FAILURE_RETRIES,
 356                             PolicyResult.FAILURE_TIMEOUT);
 357             assertTrue(builder.calculateTimeout().equals(new Integer(300 + 600)));
 358             //
 359         } catch (BuilderException e) {
 360             fail(e.getMessage());
 361         }
 362     }
 363
 364     @Test
 365     public void testTriggerPolicyMethods() {
 366         try {
 367             ControlLoopPolicyBuilder builder =
 368                     ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 369             //
 370             // Test isOpenLoop
 371             //
 372             assertTrue(builder.isOpenLoop());
 373             //
 374             // Test set initial trigger policy
 375             //
 376             Policy triggerPolicy1 =
 377                     builder.setTriggerPolicy(
 378                             PolicyParam.builder().id(UUID.randomUUID().toString())
 379                             .name("Restart the VM")
 380                             .description("Upon getting the trigger event, restart the VM")
 381                             .actor("APPC")
 382                             .target(new Target(TargetType.VM))
 383                             .recipe("Restart")
 384                             .payload(null)
 385                             .retries(2)
 386                             .timeout(300).build());
 387             assertTrue(builder.isOpenLoop() == false);
 388             assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
 389             //
 390             // Set trigger policy to a new policy
 391             //
 392             @SuppressWarnings("unused")
 393             Policy triggerPolicy2 =
 394                     builder.setTriggerPolicy(
 395                             PolicyParam.builder()
 396                             .id(UUID.randomUUID().toString())
 397                             .name("Rebuild the VM")
 398                             .description("Upon getting the trigger event, rebuild the VM")
 399                             .actor("APPC")
 400                             .target(new Target(TargetType.VM))
 401                             .recipe("Rebuild")
 402                             .payload(null)
 403                             .retries(2)
 404                             .timeout(300).build());
 405             //
 406             // Test set trigger policy to another existing policy
 407             //
 408             @SuppressWarnings("unused")
 409             ControlLoop cl = builder.setExistingTriggerPolicy(triggerPolicy1.getId());
 410             assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
 411             //
 412             // Test get trigger policy
 413             //
 414             assertTrue(builder.getTriggerPolicy().equals(triggerPolicy1));
 415             //
 416         } catch (BuilderException e) {
 417             fail(e.getMessage());
 418         }
 419     }
 420
 421     @Test
 422     public void testSetTriggerPolicyNullPolicyId() throws BuilderException {
 423         ControlLoopPolicyBuilder builder =
 424                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 425         expectedException.expect(BuilderException.class);
 426         expectedException.expectMessage("Id must not be null");
 427         builder.setExistingTriggerPolicy(null);
 428     }
 429
 430     @Test
 431     public void testSetTriggerPolicyNoPoliciesExist() throws BuilderException {
 432         ControlLoopPolicyBuilder builder =
 433                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 434         final String unknownPolicyId = "100";
 435         expectedException.expect(BuilderException.class);
 436         expectedException.expectMessage("Unknown policy " + unknownPolicyId);
 437         builder.setExistingTriggerPolicy(unknownPolicyId);
 438     }
 439
 440     @Test
 441     public void testSetTriggerPolicyUnknownPolicy() throws BuilderException {
 442         ControlLoopPolicyBuilder builder =
 443                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 444         builder.setTriggerPolicy(
 445                 PolicyParam.builder()
 446                 .id(UUID.randomUUID().toString())
 447                 .name("Restart the VM")
 448                 .description("Upon getting the trigger event, restart the VM")
 449                 .actor("APPC")
 450                 .target(new Target(TargetType.VM))
 451                 .recipe("Restart")
 452                 .payload(null)
 453                 .retries(2)
 454                 .timeout(300).build());
 455         final String unknownPolicyId = "100";
 456         expectedException.expect(BuilderException.class);
 457         expectedException.expectMessage("Unknown policy " + unknownPolicyId);
 458         builder.setExistingTriggerPolicy(unknownPolicyId);
 459     }
 460
 461     @Test
 462     public void testAddRemovePolicies() {
 463         try {
 464             ControlLoopPolicyBuilder builder =
 465                     ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 466             Policy triggerPolicy =
 467                     builder.setTriggerPolicy(
 468                             PolicyParam.builder()
 469                             .id(UUID.randomUUID().toString())
 470                             .name("Restart the VM")
 471                             .description("Upon getting the trigger event, restart the VM")
 472                             .actor("APPC")
 473                             .target(new Target(TargetType.VM))
 474                             .recipe("Restart")
 475                             .payload(null)
 476                             .retries(2)
 477                             .timeout(300).build());
 478             //
 479             // Test create a policy and chain it to the results of trigger policy
 480             //
 481             Policy onRestartFailurePolicy1 = builder.setPolicyForPolicyResult(
 482                     PolicyParam.builder()
 483                     .name("Rebuild VM")
 484                     .description("If the restart fails, rebuild it.")
 485                     .actor("APPC")
 486                     .target(new Target(TargetType.VM))
 487                     .recipe("Rebuild")
 488                     .payload(null)
 489                     .retries(1)
 490                     .timeout(600)
 491                     .id(triggerPolicy.getId()).build(),
 492                     PolicyResult.FAILURE,
 493                     PolicyResult.FAILURE_EXCEPTION,
 494                     PolicyResult.FAILURE_RETRIES,
 495                     PolicyResult.FAILURE_TIMEOUT,
 496                     PolicyResult.FAILURE_GUARD);
 497             //
 498             assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy1.getId()));
 499             assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy1.getId()));
 500             assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy1.getId()));
 501             assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy1.getId()));
 502             assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy1.getId()));
 503
 504             //
 505             // Test create a policy and chain it to the results of trigger policy success
 506             //
 507             Policy onSuccessPolicy1 = builder.setPolicyForPolicyResult(
 508                     PolicyParam.builder()
 509                     .name("Do something")
 510                     .description("If the restart succeeds, do something else.")
 511                     .actor("APPC")
 512                     .target(new Target(TargetType.VM))
 513                     .recipe("SomethingElse")
 514                     .payload(null)
 515                     .retries(1)
 516                     .timeout(600)
 517                     .id(triggerPolicy.getId()).build(),
 518                     PolicyResult.SUCCESS);
 519             //
 520             assertTrue(builder.getTriggerPolicy().getSuccess().equals(onSuccessPolicy1.getId()));
 521
 522             //
 523             // Test remove policy
 524             //
 525             boolean removed = builder.removePolicy(onRestartFailurePolicy1.getId());
 526             assertTrue(removed);
 527             assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 528             assertTrue(builder.getTriggerPolicy().getFailure_retries()
 529                     .equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 530             assertTrue(builder.getTriggerPolicy().getFailure_timeout()
 531                     .equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 532             assertTrue(
 533                     builder.getTriggerPolicy().getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString()));
 534             //
 535             // Create another policy and chain it to the results of trigger policy
 536             //
 537             final Policy onRestartFailurePolicy2 =
 538                     builder.setPolicyForPolicyResult(
 539                             PolicyParam.builder()
 540                             .name("Rebuild VM")
 541                             .description("If the restart fails, rebuild it.")
 542                             .actor("APPC")
 543                             .target(new Target(TargetType.VM))
 544                             .recipe("Rebuild")
 545                             .payload(null)
 546                             .retries(2)
 547                             .timeout(600)
 548                             .id(triggerPolicy.getId()).build(),
 549                             PolicyResult.FAILURE,
 550                             PolicyResult.FAILURE_RETRIES,
 551                             PolicyResult.FAILURE_TIMEOUT);
 552             //
 553             // Test reset policy results
 554             //
 555             triggerPolicy = builder.resetPolicyResults(triggerPolicy.getId());
 556             assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 557             assertTrue(builder.getTriggerPolicy().getFailure_retries()
 558                     .equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 559             assertTrue(builder.getTriggerPolicy().getFailure_timeout()
 560                     .equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 561             //
 562             // Test set the policy results to an existing operational policy
 563             //
 564             Policy onRestartFailurePolicy3 =
 565                     builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(), triggerPolicy.getId(),
 566                             PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
 567             assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy3.getId()));
 568             assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy3.getId()));
 569             assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy3.getId()));
 570             //
 571             // Test set the policy result for success to an existing operational policy
 572             //
 573             Policy onRestartFailurePolicy4 =
 574                     builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(), triggerPolicy.getId(),
 575                             PolicyResult.FAILURE, PolicyResult.FAILURE_EXCEPTION, PolicyResult.FAILURE_GUARD,
 576                             PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT, PolicyResult.SUCCESS);
 577             assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy4.getId()));
 578             assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy4.getId()));
 579             assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy4.getId()));
 580             assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy4.getId()));
 581             assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy4.getId()));
 582             assertTrue(builder.getTriggerPolicy().getSuccess().equals(onRestartFailurePolicy4.getId()));
 583
 584             //
 585             // Test remove all existing operational policies
 586             //
 587             builder = builder.removeAllPolicies();
 588             assertTrue(builder.getControlLoop().getTrigger_policy().equals(FinalResult.FINAL_OPENLOOP.toString()));
 589             //
 590         } catch (BuilderException e) {
 591             fail(e.getMessage());
 592         }
 593     }
 594
 595     @Test
 596     public void testAddToUnknownPolicy() throws BuilderException {
 597         ControlLoopPolicyBuilder builder =
 598                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 599         final String policyId = "100";
 600         expectedException.expect(BuilderException.class);
 601         expectedException.expectMessage("Unknown policy " + policyId);
 602
 603         builder.setPolicyForPolicyResult(
 604                 PolicyParam.builder()
 605                 .name("Rebuild VM")
 606                 .description("If the restart fails, rebuild it.")
 607                 .actor("APPC")
 608                 .target(new Target(TargetType.VM))
 609                 .recipe("Rebuild")
 610                 .payload(null)
 611                 .retries(1)
 612                 .timeout(600)
 613                 .id(policyId).build(),
 614                 PolicyResult.FAILURE,
 615                 PolicyResult.FAILURE_RETRIES,
 616                 PolicyResult.FAILURE_TIMEOUT,
 617                 PolicyResult.FAILURE_GUARD);
 618     }
 619
 620     @Test
 621     public void testAddExistingPolicyToUnknownPolicy() throws BuilderException {
 622         ControlLoopPolicyBuilder builder =
 623                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 624         Policy triggerPolicy =
 625                 builder.setTriggerPolicy(
 626                         PolicyParam.builder()
 627                         .id(UUID.randomUUID().toString())
 628                         .name("Restart the VM")
 629                         .description("Upon getting the trigger event, restart the VM")
 630                         .actor("APPC")
 631                         .target(new Target(TargetType.VM))
 632                         .recipe("Restart")
 633                         .payload(null)
 634                         .retries(2)
 635                         .timeout(300).build());
 636
 637
 638         Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
 639                 PolicyParam.builder()
 640                 .name("Rebuild VM")
 641                 .description("If the restart fails, rebuild it.")
 642                 .actor("APPC")
 643                 .target(new Target(TargetType.VM))
 644                 .recipe("Rebuild")
 645                 .payload(null)
 646                 .retries(1)
 647                 .timeout(600)
 648                 .id(triggerPolicy.getId()).build(),
 649                 PolicyResult.FAILURE);
 650
 651         final String unknownPolicyId = "100";
 652         expectedException.expect(BuilderException.class);
 653         expectedException.expectMessage(unknownPolicyId + " does not exist");
 654
 655         builder.setPolicyForPolicyResult(onRestartFailurePolicy.getId(), unknownPolicyId, PolicyResult.FAILURE);
 656     }
 657
 658     @Test
 659     public void testAddUnknownExistingPolicyToPolicy() throws BuilderException {
 660         ControlLoopPolicyBuilder builder =
 661                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 662         Policy triggerPolicy =
 663                 builder.setTriggerPolicy(
 664                         PolicyParam.builder()
 665                         .id(UUID.randomUUID().toString())
 666                         .name("Restart the VM")
 667                         .description("Upon getting the trigger event, restart the VM")
 668                         .actor("APPC")
 669                         .target(new Target(TargetType.VM))
 670                         .recipe("Restart")
 671                         .payload(null)
 672                         .retries(2)
 673                         .timeout(300).build());
 674
 675         final String unknownPolicyId = "100";
 676         expectedException.expect(BuilderException.class);
 677         expectedException.expectMessage("Operational policy " + unknownPolicyId + " does not exist");
 678
 679         builder.setPolicyForPolicyResult(unknownPolicyId, triggerPolicy.getId(), PolicyResult.FAILURE);
 680     }
 681
 682     @Test
 683     public void testAddOperationsAccumulateParams() {
 684         try {
 685             ControlLoopPolicyBuilder builder =
 686                     ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 687             Policy triggerPolicy =
 688                     builder.setTriggerPolicy(
 689                             PolicyParam.builder()
 690                             .id(UUID.randomUUID().toString())
 691                             .name("Restart the eNodeB")
 692                             .description("Upon getting the trigger event, restart the eNodeB")
 693                             .actor("RANController")
 694                             .target(new Target(TargetType.PNF))
 695                             .recipe("Restart")
 696                             .payload(null)
 697                             .retries(2)
 698                             .timeout(300).build());
 699             //
 700             // Add the operationsAccumulateParams
 701             //
 702             triggerPolicy = builder.addOperationsAccumulateParams(triggerPolicy.getId(),
 703                     new OperationsAccumulateParams("15m", 5));
 704             assertNotNull(builder.getTriggerPolicy().getOperationsAccumulateParams());
 705             assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getPeriod().equals("15m"));
 706             assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getLimit() == 5);
 707             //
 708         } catch (BuilderException e) {
 709             fail(e.getMessage());
 710         }
 711     }
 712
 713
 714     @Test
 715     public void testBuildSpecification() {
 716         try {
 717             //
 718             // Create the builder
 719             //
 720             ControlLoopPolicyBuilder builder =
 721                     ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 800);
 722             //
 723             // Set the first invalid trigger policy
 724             //
 725             final Policy policy1 = builder.setTriggerPolicy(
 726                     PolicyParam.builder()
 727                     .id(UUID.randomUUID().toString())
 728                     .name("Restart the VM")
 729                     .description("Upon getting the trigger event, restart the VM")
 730                     .actor(null)
 731                     .target(null)
 732                     .recipe("Instantiate")
 733                     .payload(null)
 734                     .retries(2)
 735                     .timeout(300).build());
 736             Results results = builder.buildSpecification();
 737             //
 738             // Check that ERRORs are in results for invalid policy arguments
 739             //
 740             boolean invalidActor = false;
 741             boolean invalidRecipe = false;
 742             boolean invalidTarget = false;
 743             for (Message m : results.getMessages()) {
 744                 if (m.getMessage().equals("Policy actor is null") && m.getLevel() == MessageLevel.ERROR) {
 745                     invalidActor = true;
 746                 }
 747                 if (m.getMessage().equals("Policy recipe is invalid") && m.getLevel() == MessageLevel.ERROR) {
 748                     invalidRecipe = true;
 749                 }
 750                 if (m.getMessage().equals("Policy target is null") && m.getLevel() == MessageLevel.ERROR) {
 751                     invalidTarget = true;
 752                 }
 753             }
 754             //
 755             assertTrue(invalidActor);
 756             assertTrue(invalidRecipe);
 757             assertTrue(invalidTarget);
 758             //
 759             // Remove the invalid policy
 760             //
 761             // @SuppressWarnings("unused")
 762             boolean removed = builder.removePolicy(policy1.getId());
 763             assertTrue(removed);
 764             assertTrue(builder.getTriggerPolicy() == null);
 765             //
 766             // Set a valid trigger policy
 767             //
 768             Policy policy1a = builder.setTriggerPolicy(
 769                     PolicyParam.builder()
 770                     .id(UUID.randomUUID().toString())
 771                     .name("Rebuild VM")
 772                     .description("If the restart fails, rebuild it.")
 773                     .actor("APPC")
 774                     .target(new Target(TargetType.VM))
 775                     .recipe("Rebuild")
 776                     .payload(null)
 777                     .retries(1)
 778                     .timeout(600).build());
 779             //
 780             // Set a second valid trigger policy
 781             //
 782             final Policy policy2 =
 783                     builder.setTriggerPolicy(
 784                             PolicyParam.builder()
 785                             .id(UUID.randomUUID().toString())
 786                             .name("Restart the VM")
 787                             .description("Upon getting the trigger event, restart the VM")
 788                             .actor("APPC")
 789                             .target(new Target(TargetType.VM))
 790                             .recipe("Restart")
 791                             .payload(null)
 792                             .retries(2)
 793                             .timeout(300).build());
 794             //
 795             // Now, we have policy1 unreachable
 796             //
 797             results = builder.buildSpecification();
 798             boolean unreachable = false;
 799             for (Message m : results.getMessages()) {
 800                 if (m.getMessage().equals("Policy " + policy1a.getId() + " is not reachable.")
 801                         && m.getLevel() == MessageLevel.WARNING) {
 802                     unreachable = true;
 803                     break;
 804                 }
 805             }
 806             assertTrue(unreachable);
 807             //
 808             // Set policy1a for the failure results of policy2
 809             //
 810             policy1a = builder.setPolicyForPolicyResult(policy1a.getId(), policy2.getId(), PolicyResult.FAILURE,
 811                     PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
 812             results = builder.buildSpecification();
 813             boolean invalidTimeout = false;
 814             for (Message m : results.getMessages()) {
 815                 if (m.getMessage()
 816                         .equals("controlLoop overall timeout is less than the sum of operational policy timeouts.")
 817                         && m.getLevel() == MessageLevel.ERROR) {
 818                     invalidTimeout = true;
 819                     break;
 820                 }
 821             }
 822             assertTrue(invalidTimeout);
 823             //
 824             // Remove policy2 (revert controlLoop back to open loop)
 825             //
 826             removed = builder.removePolicy(policy2.getId());
 827             //
 828             // ControlLoop is open loop now, but it still has policies (policy1)
 829             //
 830             results = builder.buildSpecification();
 831             unreachable = false;
 832             for (Message m : results.getMessages()) {
 833                 if (m.getMessage().equals("Open Loop policy contains policies. The policies will never be invoked.")
 834                         && m.getLevel() == MessageLevel.WARNING) {
 835                     unreachable = true;
 836                     break;
 837                 }
 838             }
 839             assertTrue(unreachable);
 840             //
 841         } catch (BuilderException e) {
 842             fail(e.getMessage());
 843         }
 844     }
 845
 846
 847     @Test
 848     public void test1() {
 849         this.test("src/test/resources/v1.0.0/policy_Test.yaml");
 850     }
 851
 852     @Test
 853     public void testEvilYaml() {
 854         try (InputStream is = new FileInputStream(new File("src/test/resources/v1.0.0/test_evil.yaml"))) {
 855             //
 856             // Read the yaml into our Java Object
 857             //
 858             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 859             yaml.load(is);
 860         } catch (FileNotFoundException e) {
 861             fail(e.getLocalizedMessage());
 862         } catch (IOException e) {
 863             fail(e.getLocalizedMessage());
 864         } catch (YAMLException e) {
 865             //
 866             // Should have this
 867             //
 868         }
 869     }
 870
 871     /**
 872      * Does the actual test.
 873      *
 874      * @param testFile input file
 875      */
 876     public void test(String testFile) {
 877         try (InputStream is = new FileInputStream(new File(testFile))) {
 878             //
 879             // Read the yaml into our Java Object
 880             //
 881             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 882             Object obj = yaml.load(is);
 883             assertNotNull(obj);
 884             assertTrue(obj instanceof ControlLoopPolicy);
 885             ControlLoopPolicy policyTobuild = (ControlLoopPolicy) obj;
 886             //
 887             // Now we're going to try to use the builder to build this.
 888             //
 889             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(
 890                     policyTobuild.getControlLoop().getControlLoopName(), policyTobuild.getControlLoop().getTimeout());
 891             //
 892             // Add services
 893             //
 894             if (policyTobuild.getControlLoop().getServices() != null) {
 895                 builder = builder.addService(policyTobuild.getControlLoop().getServices()
 896                         .toArray(new Service[policyTobuild.getControlLoop().getServices().size()]));
 897             }
 898             //
 899             // Add resources
 900             //
 901             if (policyTobuild.getControlLoop().getResources() != null) {
 902                 builder = builder.addResource(policyTobuild.getControlLoop().getResources()
 903                         .toArray(new Resource[policyTobuild.getControlLoop().getResources().size()]));
 904             }
 905             //
 906             // Set pnf
 907             //
 908             if (policyTobuild.getControlLoop().getPnf() != null) {
 909                 builder = builder.setPNF(policyTobuild.getControlLoop().getPnf());
 910             }
 911             //
 912             // Add the policies and be sure to set the trigger policy
 913             //
 914             if (policyTobuild.getPolicies() != null) {
 915                 for (Policy policy : policyTobuild.getPolicies()) {
 916                     if (policy.getId() == policyTobuild.getControlLoop().getTrigger_policy()) {
 917                         builder.setTriggerPolicy(
 918                                 PolicyParam.builder()
 919                                 .id(UUID.randomUUID().toString())
 920                                 .name(policy.getName())
 921                                 .description(policy.getDescription())
 922                                 .actor(policy.getActor())
 923                                 .target(policy.getTarget())
 924                                 .recipe(policy.getRecipe())
 925                                 .payload(null)
 926                                 .retries(policy.getRetry())
 927                                 .timeout(policy.getTimeout()).build());
 928                     }
 929                 }
 930             }
 931
 932             // Question : how to change policy ID and results by using builder ??
 933
 934             @SuppressWarnings("unused")
 935             Results results = builder.buildSpecification();
 936
 937         } catch (FileNotFoundException e) {
 938             fail(e.getLocalizedMessage());
 939         } catch (IOException e) {
 940             fail(e.getLocalizedMessage());
 941         } catch (BuilderException e) {
 942             fail(e.getLocalizedMessage());
 943         }
 944
 945     }
 946
 947 }