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-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
  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.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;
  30
  31 import java.io.File;
  32 import java.io.FileInputStream;
  33 import java.io.InputStream;
  34 import java.util.UUID;
  35
  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;
  50
  51 public class ControlLoopPolicyBuilderTest {
  52
  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.";
  61
  62     @Test
  63     public void testControlLoop() throws BuilderException {
  64         //
  65         // Create a builder for our policy
  66         //
  67         ControlLoopPolicyBuilder builder =
  68             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
  69         //
  70         // Test add services
  71         //
  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);
  77         //
  78         // Test remove services
  79         //
  80         builder = builder.removeService(scp);
  81         assertTrue(builder.getControlLoop().getServices().size() == 2);
  82         builder = builder.removeAllServices();
  83         assertTrue(builder.getControlLoop().getServices().isEmpty());
  84         //
  85         // Test add resources
  86         //
  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);
  92         //
  93         // Test remove resources
  94         //
  95         builder = builder.removeResource(cts);
  96         assertTrue(builder.getControlLoop().getResources().size() == 2);
  97         builder = builder.removeAllResources();
  98         assertTrue(builder.getControlLoop().getResources().isEmpty());
  99     }
 100
 101     @Test
 102     public void testAddNullService() throws BuilderException {
 103         ControlLoopPolicyBuilder builder =
 104             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 105
 106         assertThatThrownBy(() -> {
 107             builder.addService((Service) null);
 108         }).isInstanceOf(BuilderException.class).hasMessage("Service must not be null");
 109     }
 110
 111     @Test
 112     public void testAddInvalidService() throws BuilderException {
 113         ControlLoopPolicyBuilder builder =
 114             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 115
 116         assertThatThrownBy(() -> {
 117             builder.addService(new Service());
 118         }).isInstanceOf(BuilderException.class)
 119             .hasMessage("Invalid service - need either a serviceUUID or serviceName");
 120     }
 121
 122     @Test
 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);
 130     }
 131
 132     @Test
 133     public void testAddNullResource() throws BuilderException {
 134         ControlLoopPolicyBuilder builder =
 135             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 136
 137         assertThatThrownBy(() -> {
 138             builder.addResource((Resource) null);
 139         }).isInstanceOf(BuilderException.class).hasMessage("Resource must not be null");
 140     }
 141
 142     @Test
 143     public void testAddInvalidResource() throws BuilderException {
 144         ControlLoopPolicyBuilder builder =
 145             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 146
 147         assertThatThrownBy(() -> {
 148             builder.addResource(new Resource());
 149         }).isInstanceOf(BuilderException.class)
 150             .hasMessage("Invalid resource - need either resourceUUID or resourceName");
 151     }
 152
 153     @Test
 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);
 161
 162         builder.removeResource(resourceWithUuid);
 163         assertTrue(builder.getControlLoop().getResources().isEmpty());
 164     }
 165
 166     @Test
 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);
 172
 173         assertThatThrownBy(() -> {
 174             builder.removeResource((Resource) null);
 175         }).isInstanceOf(BuilderException.class).hasMessage("Resource must not be null");
 176     }
 177
 178     @Test
 179     public void testRemoveResourceNoExistingResources() throws BuilderException {
 180         ControlLoopPolicyBuilder builder =
 181             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 182
 183         assertThatThrownBy(() -> {
 184             builder.removeResource(new Resource(RESOURCE1, ResourceType.VF));
 185         }).isInstanceOf(BuilderException.class).hasMessage("No existing resources to remove");
 186     }
 187
 188     @Test
 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);
 194
 195         assertThatThrownBy(() -> {
 196             builder.removeResource(new Resource());
 197         }).isInstanceOf(BuilderException.class)
 198             .hasMessage("Invalid resource - need either a resourceUUID or resourceName");
 199     }
 200
 201     @Test
 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";
 208
 209         assertThatThrownBy(() -> {
 210             builder.removeResource(new Resource(unknownResourceName, ResourceType.VF));
 211         }).isInstanceOf(BuilderException.class).hasMessage("Unknown resource " + unknownResourceName);
 212     }
 213
 214     @Test
 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);
 223     }
 224
 225     @Test
 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);
 234     }
 235
 236     @Test
 237     @Ignore
 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
 240     // copied using
 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 {
 246         Pnf pnf = new Pnf();
 247         // pnf.setPnfType(PnfType.ENODEB);
 248         ControlLoopPolicyBuilder builder =
 249             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, pnf);
 250         assertEquals(pnf, builder.getControlLoop().getPnf());
 251
 252         builder.removePnf();
 253         assertNull(builder.getControlLoop().getPnf());
 254     }
 255
 256     @Test
 257     @Ignore
 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());
 263
 264         Pnf pnf = new Pnf();
 265         // pnf.setPnfType(PnfType.ENODEB);
 266         builder.setPnf(pnf);
 267         assertEquals(pnf, builder.getControlLoop().getPnf());
 268
 269         builder.removePnf();
 270         assertNull(builder.getControlLoop().getPnf());
 271     }
 272
 273     @Test
 274     public void testSetNullPnf() throws BuilderException {
 275         ControlLoopPolicyBuilder builder =
 276             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 277
 278         assertThatThrownBy(() -> {
 279             builder.setPnf(null);
 280         }).isInstanceOf(BuilderException.class).hasMessage("PNF must not be null");
 281     }
 282
 283     @Test
 284     public void testSetInvalidPnf() throws BuilderException {
 285         ControlLoopPolicyBuilder builder =
 286             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 287
 288         assertThatThrownBy(() -> {
 289             builder.setPnf(new Pnf());
 290         }).isInstanceOf(BuilderException.class).hasMessage("Invalid PNF - need either pnfName or pnfType");
 291     }
 292
 293     @Test
 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());
 300     }
 301
 302     @Test
 303     public void testSetNullAbatement() throws BuilderException {
 304         assertThatThrownBy(() -> {
 305             ControlLoopPolicyBuilder builder =
 306                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 307
 308             builder = builder.setAbatement(null);
 309         }).isInstanceOf(BuilderException.class).hasMessage("abatement must not be null");
 310     }
 311
 312     @Test
 313     public void testTimeout() throws BuilderException {
 314         //
 315         // Create a builder for our policy
 316         //
 317         ControlLoopPolicyBuilder builder =
 318             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 319         //
 320         // Test setTimeout
 321         //
 322         assertTrue(builder.getControlLoop().getTimeout() == 2400);
 323         builder = builder.setTimeout(800);
 324         assertTrue(builder.getControlLoop().getTimeout() == 800);
 325         //
 326         // Test calculateTimeout
 327         //
 328         // @formatter:off
 329         Policy trigger = builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
 330             .name(RESTART_VM)
 331             .description(TRIGGER_RESTART)
 332             .actor("APPC").target(new Target(TargetType.VM))
 333             .recipe(RESTART)
 334             .payload(null)
 335             .retries(2)
 336             .timeout(300)
 337             .build());
 338
 339         @SuppressWarnings("unused")
 340         Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
 341             PolicyParam.builder()
 342                 .name(REBUILD_VM)
 343                 .description("If the restart fails, rebuild it").actor("APPC")
 344                 .target(new Target(TargetType.VM))
 345                 .recipe(REBUILD)
 346                 .payload(null)
 347                 .retries(1)
 348                 .timeout(600)
 349                 .id(trigger.getId())
 350                 .build(),
 351             PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
 352         assertEquals(Integer.valueOf(300 + 600), builder.calculateTimeout());
 353         // @formatter:on
 354     }
 355
 356     @Test
 357     public void testTriggerPolicyMethods() throws BuilderException {
 358         ControlLoopPolicyBuilder builder =
 359             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 360         //
 361         // Test isOpenLoop
 362         //
 363         assertTrue(builder.isOpenLoop());
 364         //
 365         // Test set initial trigger policy
 366         //
 367         // @formatter:off
 368         Policy triggerPolicy1 = builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
 369             .name(RESTART_VM)
 370             .description(TRIGGER_RESTART)
 371             .actor("APPC")
 372             .target(new Target(TargetType.VM))
 373             .recipe(RESTART)
 374             .payload(null)
 375             .retries(2)
 376             .timeout(300)
 377             .build());
 378         assertFalse(builder.isOpenLoop());
 379         assertEquals(builder.getControlLoop().getTrigger_policy(), triggerPolicy1.getId());
 380         //
 381         // Set trigger policy to a new policy
 382         //
 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))
 388             .recipe(REBUILD)
 389             .payload(null)
 390             .retries(2)
 391             .timeout(300)
 392             .build());
 393         // @formatter:on
 394         //
 395         // Test set trigger policy to another existing policy
 396         //
 397         @SuppressWarnings("unused")
 398         ControlLoop cl = builder.setExistingTriggerPolicy(triggerPolicy1.getId());
 399         assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
 400         //
 401         // Test get trigger policy
 402         //
 403         assertTrue(builder.getTriggerPolicy().equals(triggerPolicy1));
 404     }
 405
 406     @Test
 407     public void testSetTriggerPolicyNullPolicyId() throws BuilderException {
 408         ControlLoopPolicyBuilder builder =
 409             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 410
 411         assertThatThrownBy(() -> {
 412             builder.setExistingTriggerPolicy(null);
 413         }).isInstanceOf(BuilderException.class).hasMessage("Id must not be null");
 414     }
 415
 416     @Test
 417     public void testSetTriggerPolicyNoPoliciesExist() throws BuilderException {
 418         ControlLoopPolicyBuilder builder =
 419             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 420         final String unknownPolicyId = "100";
 421
 422         assertThatThrownBy(() -> {
 423             builder.setExistingTriggerPolicy(unknownPolicyId);
 424         }).isInstanceOf(BuilderException.class).hasMessage(UNKNOWN_POLICY + unknownPolicyId);
 425     }
 426
 427     @Test
 428     public void testSetTriggerPolicyUnknownPolicy() throws BuilderException {
 429         ControlLoopPolicyBuilder builder =
 430             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 431         // @formatter:off
 432         builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
 433             .name(RESTART_VM)
 434             .description(TRIGGER_RESTART)
 435             .actor("APPC")
 436             .target(new Target(TargetType.VM))
 437             .recipe(RESTART)
 438             .payload(null)
 439             .retries(2)
 440             .timeout(300)
 441             .build());
 442         // @formatter:on
 443         final String unknownPolicyId = "100";
 444
 445         assertThatThrownBy(() -> {
 446             builder.setExistingTriggerPolicy(unknownPolicyId);
 447         }).isInstanceOf(BuilderException.class).hasMessage(UNKNOWN_POLICY + unknownPolicyId);
 448     }
 449
 450     @Test
 451     public void testAddRemovePolicies() throws BuilderException {
 452         ControlLoopPolicyBuilder builder =
 453             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 454         // @formatter:off
 455         Policy triggerPolicy = builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
 456             .name(RESTART_VM)
 457             .description(TRIGGER_RESTART)
 458             .actor("APPC")
 459             .target(new Target(TargetType.VM))
 460             .recipe(RESTART)
 461             .payload(null)
 462             .retries(2)
 463             .timeout(300)
 464             .build());
 465         //
 466         // Test create a policy and chain it to the results of trigger policy
 467         //
 468         Policy onRestartFailurePolicy1 = builder.setPolicyForPolicyResult(PolicyParam.builder()
 469             .name(REBUILD_VM)
 470             .description(REBUILD_RESTART)
 471             .actor("APPC")
 472             .target(new Target(TargetType.VM))
 473             .recipe(REBUILD).payload(null)
 474             .retries(1)
 475             .timeout(600)
 476             .id(triggerPolicy.getId())
 477             .build(),
 478             PolicyResult.FAILURE, PolicyResult.FAILURE_EXCEPTION, PolicyResult.FAILURE_RETRIES,
 479             PolicyResult.FAILURE_TIMEOUT, PolicyResult.FAILURE_GUARD);
 480         //
 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()));
 486
 487         //
 488         // Test create a policy and chain it to the results of trigger policy success
 489         //
 490         Policy onSuccessPolicy1 = builder.setPolicyForPolicyResult(PolicyParam.builder()
 491             .name("Do something")
 492             .description("If the restart succeeds, do something else.")
 493             .actor("APPC")
 494             .target(new Target(TargetType.VM))
 495             .recipe("SomethingElse")
 496             .payload(null)
 497             .retries(1)
 498             .timeout(600)
 499             .id(triggerPolicy.getId())
 500             .build(),
 501             PolicyResult.SUCCESS);
 502         //
 503         // @formatter:on
 504         assertTrue(builder.getTriggerPolicy().getSuccess().equals(onSuccessPolicy1.getId()));
 505
 506         //
 507         // Test remove policy
 508         //
 509         boolean removed = builder.removePolicy(onRestartFailurePolicy1.getId());
 510         assertTrue(removed);
 511         assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 512         assertTrue(
 513             builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 514         assertTrue(
 515             builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 516         assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString()));
 517         //
 518         // Create another policy and chain it to the results of trigger policy
 519         //
 520         // @formatter:off
 521         final Policy onRestartFailurePolicy2 = builder.setPolicyForPolicyResult(
 522             PolicyParam.builder()
 523                 .name(REBUILD_VM)
 524                 .description(REBUILD_RESTART)
 525                 .actor("APPC")
 526                 .target(new Target(TargetType.VM))
 527                 .recipe(REBUILD)
 528                 .payload(null)
 529                 .retries(2)
 530                 .timeout(600)
 531                 .id(triggerPolicy.getId())
 532                 .build(),
 533             PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
 534         // @formatter:on
 535         //
 536         // Test reset policy results
 537         //
 538         triggerPolicy = builder.resetPolicyResults(triggerPolicy.getId());
 539         assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 540         assertTrue(
 541             builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 542         assertTrue(
 543             builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 544         //
 545         // Test set the policy results to an existing operational policy
 546         //
 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()));
 552         //
 553         // Test set the policy result for success to an existing operational policy
 554         //
 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()));
 564
 565         //
 566         // Test remove all existing operational policies
 567         //
 568         builder = builder.removeAllPolicies();
 569         assertTrue(builder.getControlLoop().getTrigger_policy().equals(FinalResult.FINAL_OPENLOOP.toString()));
 570     }
 571
 572     @Test
 573     public void testAddToUnknownPolicy() throws BuilderException {
 574         ControlLoopPolicyBuilder builder =
 575             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 576         final String policyId = "100";
 577
 578         assertThatThrownBy(() -> {
 579             // @formatter:off
 580             builder.setPolicyForPolicyResult(
 581                 PolicyParam.builder()
 582                     .name(REBUILD_VM)
 583                     .description(REBUILD_RESTART)
 584                     .actor("APPC")
 585                     .target(new Target(TargetType.VM))
 586                     .recipe(REBUILD)
 587                     .payload(null)
 588                     .retries(1)
 589                     .timeout(600)
 590                     .id(policyId)
 591                     .build(),
 592                 PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT,
 593                 PolicyResult.FAILURE_GUARD);
 594             // @formatter:on
 595         }).isInstanceOf(BuilderException.class).hasMessage(UNKNOWN_POLICY + policyId);
 596
 597     }
 598
 599     @Test
 600     public void testAddExistingPolicyToUnknownPolicy() throws BuilderException {
 601         ControlLoopPolicyBuilder builder =
 602             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 603         // @formatter:off
 604         Policy triggerPolicy = builder.setTriggerPolicy(PolicyParam.builder()
 605             .id(UUID.randomUUID().toString())
 606             .name(RESTART_VM)
 607             .description(TRIGGER_RESTART)
 608             .actor("APPC")
 609             .target(new Target(TargetType.VM))
 610             .recipe(RESTART)
 611             .payload(null)
 612             .retries(2)
 613             .timeout(300)
 614             .build());
 615
 616         Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(PolicyParam.builder()
 617             .name(REBUILD_VM)
 618             .description(REBUILD_RESTART)
 619             .actor("APPC")
 620             .target(new Target(TargetType.VM))
 621             .recipe(REBUILD)
 622             .payload(null)
 623             .retries(1)
 624             .timeout(600)
 625             .id(triggerPolicy.getId())
 626             .build(),
 627             PolicyResult.FAILURE);
 628
 629         // @formatter:on
 630         final String unknownPolicyId = "100";
 631
 632         assertThatThrownBy(() -> {
 633             builder.setPolicyForPolicyResult(onRestartFailurePolicy.getId(), unknownPolicyId, PolicyResult.FAILURE);
 634         }).isInstanceOf(BuilderException.class).hasMessage(unknownPolicyId + " does not exist");
 635
 636     }
 637
 638     @Test
 639     public void testAddUnknownExistingPolicyToPolicy() throws BuilderException {
 640         ControlLoopPolicyBuilder builder =
 641             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 642         // @formatter:off
 643         Policy triggerPolicy = builder.setTriggerPolicy(PolicyParam.builder()
 644             .id(UUID.randomUUID().toString())
 645             .name(RESTART_VM)
 646             .description(TRIGGER_RESTART)
 647             .actor("APPC")
 648             .target(new Target(TargetType.VM))
 649             .recipe(RESTART)
 650             .payload(null)
 651             .retries(2)
 652             .timeout(300)
 653             .build());
 654         // @formatter:on
 655
 656         final String unknownPolicyId = "100";
 657
 658         assertThatThrownBy(() -> {
 659             builder.setPolicyForPolicyResult(unknownPolicyId, triggerPolicy.getId(), PolicyResult.FAILURE);
 660         }).isInstanceOf(BuilderException.class).hasMessage("Operational policy " + unknownPolicyId + " does not exist");
 661
 662     }
 663
 664     @Test
 665     public void testAddOperationsAccumulateParams() throws BuilderException {
 666         ControlLoopPolicyBuilder builder =
 667             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 668         // @formatter:off
 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))
 676                 .recipe(RESTART)
 677                 .payload(null)
 678                 .retries(2)
 679                 .timeout(300)
 680                 .build());
 681         // @formatter:on
 682         //
 683         // Add the operationsAccumulateParams
 684         //
 685         triggerPolicy =
 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);
 690     }
 691
 692     @Test
 693     public void testBuildSpecification() throws BuilderException {
 694         //
 695         // Create the builder
 696         //
 697         ControlLoopPolicyBuilder builder =
 698             ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 800);
 699         //
 700         // Set the first invalid trigger policy
 701         //
 702         // @formatter:off
 703         final Policy policy1 = builder.setTriggerPolicy(
 704             PolicyParam.builder()
 705                 .id(UUID.randomUUID().toString())
 706                 .name(RESTART_VM)
 707                 .description(TRIGGER_RESTART)
 708                 .actor(null)
 709                 .target(null)
 710                 .recipe(null)
 711                 .payload(null)
 712                 .retries(2)
 713                 .timeout(300)
 714                 .build());
 715         Results results = builder.buildSpecification();
 716         // @formatter:on
 717         //
 718         // Check that ERRORs are in results for invalid policy arguments
 719         //
 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) {
 725                 invalidActor = true;
 726             }
 727             if ("Policy recipe is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
 728                 invalidRecipe = true;
 729             }
 730             if ("Policy target is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
 731                 invalidTarget = true;
 732             }
 733         }
 734         //
 735         assertTrue(invalidActor);
 736         assertTrue(invalidRecipe);
 737         assertTrue(invalidTarget);
 738         //
 739         // Remove the invalid policy
 740         //
 741         // @SuppressWarnings("unused")
 742         boolean removed = builder.removePolicy(policy1.getId());
 743         assertTrue(removed);
 744         assertTrue(builder.getTriggerPolicy() == null);
 745         //
 746         // Set a valid trigger policy
 747         //
 748         // @formatter:off
 749         Policy policy1a = builder.setTriggerPolicy(PolicyParam.builder()
 750             .id(UUID.randomUUID().toString())
 751             .name(REBUILD_VM)
 752             .description(REBUILD_RESTART)
 753             .actor("APPC")
 754             .target(new Target(TargetType.VM))
 755             .recipe(REBUILD)
 756             .payload(null)
 757             .retries(1)
 758             .timeout(600)
 759             .build());
 760         //
 761         // Set a second valid trigger policy
 762         //
 763         final Policy policy2 = builder.setTriggerPolicy(PolicyParam.builder()
 764             .id(UUID.randomUUID().toString())
 765             .name(RESTART_VM)
 766             .description(TRIGGER_RESTART)
 767             .actor("APPC")
 768             .target(new Target(TargetType.VM))
 769             .recipe(RESTART)
 770             .payload(null)
 771             .retries(2)
 772             .timeout(300)
 773             .build());
 774         // @formatter:on
 775         //
 776         // Now, we have policy1 unreachable
 777         //
 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) {
 783                 unreachable = true;
 784                 break;
 785             }
 786         }
 787         assertTrue(unreachable);
 788         //
 789         // Set policy1a for the failure results of policy2
 790         //
 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;
 799                 break;
 800             }
 801         }
 802         assertTrue(invalidTimeout);
 803         //
 804         // Remove policy2 (revert controlLoop back to open loop)
 805         //
 806         removed = builder.removePolicy(policy2.getId());
 807         //
 808         // ControlLoop is open loop now, but it still has policies (policy1)
 809         //
 810         results = builder.buildSpecification();
 811         unreachable = false;
 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) {
 815                 unreachable = true;
 816                 break;
 817             }
 818         }
 819         assertTrue(unreachable);
 820     }
 821
 822     @Test
 823     public void test1() throws Exception {
 824         this.test("src/test/resources/v1.0.0/policy_Test.yaml");
 825     }
 826
 827     @Test
 828     public void testEvilYaml() throws Exception {
 829         try (InputStream is = new FileInputStream(new File("src/test/resources/v1.0.0/test_evil.yaml"))) {
 830             //
 831             // Attempt to read the yaml into our Java Object
 832             //
 833             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 834             assertThatThrownBy(() -> yaml.load(is)).isInstanceOf(YAMLException.class);
 835         }
 836     }
 837
 838     /**
 839      * Does the actual test.
 840      *
 841      * @param testFile input file
 842      * @throws Exception if an error occurs
 843      */
 844     public void test(String testFile) throws Exception {
 845         try (InputStream is = new FileInputStream(new File(testFile))) {
 846             //
 847             // Read the yaml into our Java Object
 848             //
 849             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 850             Object obj = yaml.load(is);
 851             assertNotNull(obj);
 852             assertTrue(obj instanceof ControlLoopPolicy);
 853             ControlLoopPolicy policyTobuild = (ControlLoopPolicy) obj;
 854             //
 855             // Now we're going to try to use the builder to build this.
 856             //
 857             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(
 858                 policyTobuild.getControlLoop().getControlLoopName(), policyTobuild.getControlLoop().getTimeout());
 859             //
 860             // Add services
 861             //
 862             if (policyTobuild.getControlLoop().getServices() != null) {
 863                 builder = builder.addService(policyTobuild.getControlLoop().getServices()
 864                     .toArray(new Service[policyTobuild.getControlLoop().getServices().size()]));
 865             }
 866             //
 867             // Add resources
 868             //
 869             if (policyTobuild.getControlLoop().getResources() != null) {
 870                 builder = builder.addResource(policyTobuild.getControlLoop().getResources()
 871                     .toArray(new Resource[policyTobuild.getControlLoop().getResources().size()]));
 872             }
 873             //
 874             // Set pnf
 875             //
 876             if (policyTobuild.getControlLoop().getPnf() != null) {
 877                 builder = builder.setPnf(policyTobuild.getControlLoop().getPnf());
 878             }
 879             //
 880             // Add the policies and be sure to set the trigger policy
 881             //
 882             if (policyTobuild.getPolicies() != null) {
 883                 setTriggerPolicies(policyTobuild, builder);
 884             }
 885
 886             // Question : how to change policy ID and results by using builder ??
 887
 888             @SuppressWarnings("unused")
 889             Results results = builder.buildSpecification();
 890         }
 891
 892     }
 893
 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()) {
 898                 // @formatter:off
 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())
 905                         .payload(null)
 906                         .retries(policy.getRetry())
 907                         .timeout(policy.getTimeout())
 908                         .build());
 909                 // @formatter:on
 910             }
 911         }
 912     }
 913 }