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 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 import org.junit.Ignore;
  36 import org.junit.Rule;
  37 import org.junit.Test;
  38 import org.junit.rules.ExpectedException;
  39 import org.onap.aai.domain.yang.Pnf;
  40 import org.onap.policy.controlloop.policy.builder.BuilderException;
  41 import org.onap.policy.controlloop.policy.builder.ControlLoopPolicyBuilder;
  42 import org.onap.policy.controlloop.policy.builder.Message;
  43 import org.onap.policy.controlloop.policy.builder.MessageLevel;
  44 import org.onap.policy.controlloop.policy.builder.Results;
  45 import org.onap.policy.sdc.Resource;
  46 import org.onap.policy.sdc.ResourceType;
  47 import org.onap.policy.sdc.Service;
  48 import org.yaml.snakeyaml.Yaml;
  49 import org.yaml.snakeyaml.constructor.Constructor;
  50 import org.yaml.snakeyaml.error.YAMLException;
  51
  52
  53 public class ControlLoopPolicyBuilderTest {
  54
  55     private static final String RESOURCE1 = "resource1";
  56     private static final String TRIGGER_RESTART = "Upon getting the trigger event, restart the VM";
  57     private static final String UNKNOWN_POLICY = "Unknown policy ";
  58     private static final String RESTART = "Restart";
  59     private static final String RESTART_VM = "Restart the VM";
  60     private static final String REBUILD = "Rebuild";
  61     private static final String REBUILD_VM = "Rebuild VM";
  62     private static final String REBUILD_RESTART = "If the restart fails, rebuild it.";
  63     @Rule
  64     public ExpectedException expectedException = ExpectedException.none();
  65
  66     @Test
  67     public void testControlLoop() throws BuilderException {
  68         //
  69         // Create a builder for our policy
  70         //
  71         ControlLoopPolicyBuilder builder =
  72                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
  73         //
  74         // Test add services
  75         //
  76         Service scp = new Service("vSCP");
  77         Service usp = new Service("vUSP");
  78         Service trinity = new Service("Trinity");
  79         builder = builder.addService(scp, usp, trinity);
  80         assertTrue(builder.getControlLoop().getServices().size() == 3);
  81         //
  82         // Test remove services
  83         //
  84         builder = builder.removeService(scp);
  85         assertTrue(builder.getControlLoop().getServices().size() == 2);
  86         builder = builder.removeAllServices();
  87         assertTrue(builder.getControlLoop().getServices().isEmpty());
  88         //
  89         // Test add resources
  90         //
  91         Resource cts = new Resource("vCTS", ResourceType.VF);
  92         Resource com = new Resource("vCTS", ResourceType.VF);
  93         Resource rar = new Resource("vCTS", ResourceType.VF);
  94         builder = builder.addResource(cts, com, rar);
  95         assertTrue(builder.getControlLoop().getResources().size() == 3);
  96         //
  97         // Test remove resources
  98         //
  99         builder = builder.removeResource(cts);
 100         assertTrue(builder.getControlLoop().getResources().size() == 2);
 101         builder = builder.removeAllResources();
 102         assertTrue(builder.getControlLoop().getResources().isEmpty());
 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().isEmpty());
 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() throws BuilderException {
 210         Resource cts = new Resource("vCTS", ResourceType.VF);
 211         Service scp = new Service("vSCP");
 212         Service usp = new Service("vUSP");
 213         ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory
 214                 .buildControlLoop(UUID.randomUUID().toString(), 2400, cts, scp, usp);
 215         assertTrue(builder.getControlLoop().getResources().size() == 1);
 216         assertTrue(builder.getControlLoop().getServices().size() == 2);
 217     }
 218
 219     @Test
 220     public void testControlLoopWithInitialResourcesAndService() throws BuilderException {
 221         Resource cts = new Resource("vCTS", ResourceType.VF);
 222         Resource com = new Resource("vCTS", ResourceType.VF);
 223         Service scp = new Service("vSCP");
 224         ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory
 225                 .buildControlLoop(UUID.randomUUID().toString(), 2400, scp, cts, com);
 226         assertTrue(builder.getControlLoop().getServices().size() == 1);
 227         assertTrue(builder.getControlLoop().getResources().size() == 2);
 228     }
 229
 230     @Test
 231     @Ignore
 232     // I'VE MARKED THIS TEST CASE AS IGNORE BECAUSE THE TEST CASE FAILS
 233     // This test case fails because builder.getControlLoop() returns an instance of ControlLoop
 234     // copied using
 235     // the ControlLoop(ControlLoop controlLoop) constructor.
 236     // This constructor does not copy the value of pnf into the newly created object
 237     // On the face of it, this looks like a bug, but perhaps there is a reason for this
 238     // PLEASE ADVISE IF THE BEHAVIOUR IS INCORRECT OR THE TEST CASE IS INVALID
 239     public void testControlLoopForPnf() throws BuilderException {
 240         Pnf pnf = new Pnf();
 241         //pnf.setPnfType(PnfType.ENODEB);
 242         ControlLoopPolicyBuilder builder =
 243                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, pnf);
 244         assertEquals(pnf, builder.getControlLoop().getPnf());
 245
 246         builder.removePnf();
 247         assertNull(builder.getControlLoop().getPnf());
 248     }
 249
 250     @Test
 251     @Ignore
 252     // Fails for the same reason as the above test case
 253     public void testSetAndRemovePnf() throws BuilderException {
 254         ControlLoopPolicyBuilder builder =
 255                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 256         assertNull(builder.getControlLoop().getPnf());
 257
 258         Pnf pnf = new Pnf();
 259         //pnf.setPnfType(PnfType.ENODEB);
 260         builder.setPnf(pnf);
 261         assertEquals(pnf, builder.getControlLoop().getPnf());
 262
 263         builder.removePnf();
 264         assertNull(builder.getControlLoop().getPnf());
 265     }
 266
 267     @Test
 268     public void testSetNullPnf() throws BuilderException {
 269         ControlLoopPolicyBuilder builder =
 270                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 271         expectedException.expect(BuilderException.class);
 272         expectedException.expectMessage("PNF must not be null");
 273         builder.setPnf(null);
 274     }
 275
 276     @Test
 277     public void testSetInvalidPnf() throws BuilderException {
 278         ControlLoopPolicyBuilder builder =
 279                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 280         expectedException.expect(BuilderException.class);
 281         expectedException.expectMessage("Invalid PNF - need either pnfName or pnfType");
 282         builder.setPnf(new Pnf());
 283     }
 284
 285     @Test
 286     public void testSetAbatement() throws BuilderException {
 287         ControlLoopPolicyBuilder builder =
 288                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 289         assertFalse(builder.getControlLoop().getAbatement());
 290         builder = builder.setAbatement(true);
 291         assertTrue(builder.getControlLoop().getAbatement());
 292     }
 293
 294     @Test
 295     public void testSetNullAbatement() throws BuilderException {
 296         ControlLoopPolicyBuilder builder =
 297                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 298         expectedException.expect(BuilderException.class);
 299         expectedException.expectMessage("abatement must not be null");
 300         builder = builder.setAbatement(null);
 301     }
 302
 303     @Test
 304     public void testTimeout() throws BuilderException {
 305         //
 306         // Create a builder for our policy
 307         //
 308         ControlLoopPolicyBuilder builder =
 309                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 310         //
 311         // Test setTimeout
 312         //
 313         assertTrue(builder.getControlLoop().getTimeout() == 2400);
 314         builder = builder.setTimeout(800);
 315         assertTrue(builder.getControlLoop().getTimeout() == 800);
 316         //
 317         // Test calculateTimeout
 318         //
 319         Policy trigger =
 320                 builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
 321                         .name(RESTART_VM)
 322                         .description(TRIGGER_RESTART)
 323                         .actor("APPC")
 324                         .target(new Target(TargetType.VM))
 325                         .recipe(RESTART)
 326                         .payload(null)
 327                         .retries(2)
 328                         .timeout(300).build());
 329         @SuppressWarnings("unused")
 330         Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
 331                 PolicyParam.builder()
 332                         .name(REBUILD_VM)
 333                         .description("If the restart fails, rebuild it")
 334                         .actor("APPC")
 335                         .target(new Target(TargetType.VM))
 336                         .recipe(REBUILD)
 337                         .payload(null)
 338                         .retries(1)
 339                         .timeout(600)
 340                         .id(trigger.getId()).build(),
 341                         PolicyResult.FAILURE,
 342                         PolicyResult.FAILURE_RETRIES,
 343                         PolicyResult.FAILURE_TIMEOUT);
 344         assertEquals(Integer.valueOf(300 + 600), builder.calculateTimeout());
 345     }
 346
 347     @Test
 348     public void testTriggerPolicyMethods() throws BuilderException {
 349         ControlLoopPolicyBuilder builder =
 350                         ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 351         //
 352         // Test isOpenLoop
 353         //
 354         assertTrue(builder.isOpenLoop());
 355         //
 356         // Test set initial trigger policy
 357         //
 358         Policy triggerPolicy1 =
 359                 builder.setTriggerPolicy(
 360                         PolicyParam.builder().id(UUID.randomUUID().toString())
 361                         .name(RESTART_VM)
 362                         .description(TRIGGER_RESTART)
 363                         .actor("APPC")
 364                         .target(new Target(TargetType.VM))
 365                         .recipe(RESTART)
 366                         .payload(null)
 367                         .retries(2)
 368                         .timeout(300).build());
 369         assertFalse(builder.isOpenLoop());
 370         assertEquals(builder.getControlLoop().getTrigger_policy(), triggerPolicy1.getId());
 371         //
 372         // Set trigger policy to a new policy
 373         //
 374         @SuppressWarnings("unused")
 375         Policy triggerPolicy2 =
 376                 builder.setTriggerPolicy(
 377                         PolicyParam.builder()
 378                         .id(UUID.randomUUID().toString())
 379                         .name("Rebuild the VM")
 380                         .description("Upon getting the trigger event, rebuild the VM")
 381                         .actor("APPC")
 382                         .target(new Target(TargetType.VM))
 383                         .recipe(REBUILD)
 384                         .payload(null)
 385                         .retries(2)
 386                         .timeout(300).build());
 387         //
 388         // Test set trigger policy to another existing policy
 389         //
 390         @SuppressWarnings("unused")
 391         ControlLoop cl = builder.setExistingTriggerPolicy(triggerPolicy1.getId());
 392         assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
 393         //
 394         // Test get trigger policy
 395         //
 396         assertTrue(builder.getTriggerPolicy().equals(triggerPolicy1));
 397     }
 398
 399     @Test
 400     public void testSetTriggerPolicyNullPolicyId() throws BuilderException {
 401         ControlLoopPolicyBuilder builder =
 402                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 403         expectedException.expect(BuilderException.class);
 404         expectedException.expectMessage("Id must not be null");
 405         builder.setExistingTriggerPolicy(null);
 406     }
 407
 408     @Test
 409     public void testSetTriggerPolicyNoPoliciesExist() throws BuilderException {
 410         ControlLoopPolicyBuilder builder =
 411                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 412         final String unknownPolicyId = "100";
 413         expectedException.expect(BuilderException.class);
 414         expectedException.expectMessage(UNKNOWN_POLICY + unknownPolicyId);
 415         builder.setExistingTriggerPolicy(unknownPolicyId);
 416     }
 417
 418     @Test
 419     public void testSetTriggerPolicyUnknownPolicy() throws BuilderException {
 420         ControlLoopPolicyBuilder builder =
 421                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 422         builder.setTriggerPolicy(
 423                 PolicyParam.builder()
 424                 .id(UUID.randomUUID().toString())
 425                 .name(RESTART_VM)
 426                 .description(TRIGGER_RESTART)
 427                 .actor("APPC")
 428                 .target(new Target(TargetType.VM))
 429                 .recipe(RESTART)
 430                 .payload(null)
 431                 .retries(2)
 432                 .timeout(300).build());
 433         final String unknownPolicyId = "100";
 434         expectedException.expect(BuilderException.class);
 435         expectedException.expectMessage(UNKNOWN_POLICY + unknownPolicyId);
 436         builder.setExistingTriggerPolicy(unknownPolicyId);
 437     }
 438
 439     @Test
 440     public void testAddRemovePolicies() throws BuilderException {
 441         ControlLoopPolicyBuilder builder =
 442                         ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 443         Policy triggerPolicy =
 444                 builder.setTriggerPolicy(
 445                         PolicyParam.builder()
 446                         .id(UUID.randomUUID().toString())
 447                         .name(RESTART_VM)
 448                         .description(TRIGGER_RESTART)
 449                         .actor("APPC")
 450                         .target(new Target(TargetType.VM))
 451                         .recipe(RESTART)
 452                         .payload(null)
 453                         .retries(2)
 454                         .timeout(300).build());
 455         //
 456         // Test create a policy and chain it to the results of trigger policy
 457         //
 458         Policy onRestartFailurePolicy1 = builder.setPolicyForPolicyResult(
 459                 PolicyParam.builder()
 460                 .name(REBUILD_VM)
 461                 .description(REBUILD_RESTART)
 462                 .actor("APPC")
 463                 .target(new Target(TargetType.VM))
 464                 .recipe(REBUILD)
 465                 .payload(null)
 466                 .retries(1)
 467                 .timeout(600)
 468                 .id(triggerPolicy.getId()).build(),
 469                 PolicyResult.FAILURE,
 470                 PolicyResult.FAILURE_EXCEPTION,
 471                 PolicyResult.FAILURE_RETRIES,
 472                 PolicyResult.FAILURE_TIMEOUT,
 473                 PolicyResult.FAILURE_GUARD);
 474         //
 475         assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy1.getId()));
 476         assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy1.getId()));
 477         assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy1.getId()));
 478         assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy1.getId()));
 479         assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy1.getId()));
 480
 481         //
 482         // Test create a policy and chain it to the results of trigger policy success
 483         //
 484         Policy onSuccessPolicy1 = builder.setPolicyForPolicyResult(
 485                 PolicyParam.builder()
 486                 .name("Do something")
 487                 .description("If the restart succeeds, do something else.")
 488                 .actor("APPC")
 489                 .target(new Target(TargetType.VM))
 490                 .recipe("SomethingElse")
 491                 .payload(null)
 492                 .retries(1)
 493                 .timeout(600)
 494                 .id(triggerPolicy.getId()).build(),
 495                 PolicyResult.SUCCESS);
 496         //
 497         assertTrue(builder.getTriggerPolicy().getSuccess().equals(onSuccessPolicy1.getId()));
 498
 499         //
 500         // Test remove policy
 501         //
 502         boolean removed = builder.removePolicy(onRestartFailurePolicy1.getId());
 503         assertTrue(removed);
 504         assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 505         assertTrue(builder.getTriggerPolicy().getFailure_retries()
 506                 .equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 507         assertTrue(builder.getTriggerPolicy().getFailure_timeout()
 508                 .equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 509         assertTrue(
 510                 builder.getTriggerPolicy().getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString()));
 511         //
 512         // Create another policy and chain it to the results of trigger policy
 513         //
 514         final Policy onRestartFailurePolicy2 =
 515                 builder.setPolicyForPolicyResult(
 516                         PolicyParam.builder()
 517                         .name(REBUILD_VM)
 518                         .description(REBUILD_RESTART)
 519                         .actor("APPC")
 520                         .target(new Target(TargetType.VM))
 521                         .recipe(REBUILD)
 522                         .payload(null)
 523                         .retries(2)
 524                         .timeout(600)
 525                         .id(triggerPolicy.getId()).build(),
 526                         PolicyResult.FAILURE,
 527                         PolicyResult.FAILURE_RETRIES,
 528                         PolicyResult.FAILURE_TIMEOUT);
 529         //
 530         // Test reset policy results
 531         //
 532         triggerPolicy = builder.resetPolicyResults(triggerPolicy.getId());
 533         assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 534         assertTrue(builder.getTriggerPolicy().getFailure_retries()
 535                 .equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 536         assertTrue(builder.getTriggerPolicy().getFailure_timeout()
 537                 .equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 538         //
 539         // Test set the policy results to an existing operational policy
 540         //
 541         Policy onRestartFailurePolicy3 =
 542                 builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(), triggerPolicy.getId(),
 543                         PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
 544         assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy3.getId()));
 545         assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy3.getId()));
 546         assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy3.getId()));
 547         //
 548         // Test set the policy result for success to an existing operational policy
 549         //
 550         Policy onRestartFailurePolicy4 =
 551                 builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(), triggerPolicy.getId(),
 552                         PolicyResult.FAILURE, PolicyResult.FAILURE_EXCEPTION, PolicyResult.FAILURE_GUARD,
 553                         PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT, PolicyResult.SUCCESS);
 554         assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy4.getId()));
 555         assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy4.getId()));
 556         assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy4.getId()));
 557         assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy4.getId()));
 558         assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy4.getId()));
 559         assertTrue(builder.getTriggerPolicy().getSuccess().equals(onRestartFailurePolicy4.getId()));
 560
 561         //
 562         // Test remove all existing operational policies
 563         //
 564         builder = builder.removeAllPolicies();
 565         assertTrue(builder.getControlLoop().getTrigger_policy().equals(FinalResult.FINAL_OPENLOOP.toString()));
 566     }
 567
 568     @Test
 569     public void testAddToUnknownPolicy() throws BuilderException {
 570         ControlLoopPolicyBuilder builder =
 571                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 572         final String policyId = "100";
 573         expectedException.expect(BuilderException.class);
 574         expectedException.expectMessage(UNKNOWN_POLICY + policyId);
 575
 576         builder.setPolicyForPolicyResult(
 577                 PolicyParam.builder()
 578                 .name(REBUILD_VM)
 579                 .description(REBUILD_RESTART)
 580                 .actor("APPC")
 581                 .target(new Target(TargetType.VM))
 582                 .recipe(REBUILD)
 583                 .payload(null)
 584                 .retries(1)
 585                 .timeout(600)
 586                 .id(policyId).build(),
 587                 PolicyResult.FAILURE,
 588                 PolicyResult.FAILURE_RETRIES,
 589                 PolicyResult.FAILURE_TIMEOUT,
 590                 PolicyResult.FAILURE_GUARD);
 591     }
 592
 593     @Test
 594     public void testAddExistingPolicyToUnknownPolicy() throws BuilderException {
 595         ControlLoopPolicyBuilder builder =
 596                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 597         Policy triggerPolicy =
 598                 builder.setTriggerPolicy(
 599                         PolicyParam.builder()
 600                         .id(UUID.randomUUID().toString())
 601                         .name(RESTART_VM)
 602                         .description(TRIGGER_RESTART)
 603                         .actor("APPC")
 604                         .target(new Target(TargetType.VM))
 605                         .recipe(RESTART)
 606                         .payload(null)
 607                         .retries(2)
 608                         .timeout(300).build());
 609
 610
 611         Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
 612                 PolicyParam.builder()
 613                 .name(REBUILD_VM)
 614                 .description(REBUILD_RESTART)
 615                 .actor("APPC")
 616                 .target(new Target(TargetType.VM))
 617                 .recipe(REBUILD)
 618                 .payload(null)
 619                 .retries(1)
 620                 .timeout(600)
 621                 .id(triggerPolicy.getId()).build(),
 622                 PolicyResult.FAILURE);
 623
 624         final String unknownPolicyId = "100";
 625         expectedException.expect(BuilderException.class);
 626         expectedException.expectMessage(unknownPolicyId + " does not exist");
 627
 628         builder.setPolicyForPolicyResult(onRestartFailurePolicy.getId(), unknownPolicyId, PolicyResult.FAILURE);
 629     }
 630
 631     @Test
 632     public void testAddUnknownExistingPolicyToPolicy() throws BuilderException {
 633         ControlLoopPolicyBuilder builder =
 634                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 635         Policy triggerPolicy =
 636                 builder.setTriggerPolicy(
 637                         PolicyParam.builder()
 638                         .id(UUID.randomUUID().toString())
 639                         .name(RESTART_VM)
 640                         .description(TRIGGER_RESTART)
 641                         .actor("APPC")
 642                         .target(new Target(TargetType.VM))
 643                         .recipe(RESTART)
 644                         .payload(null)
 645                         .retries(2)
 646                         .timeout(300).build());
 647
 648         final String unknownPolicyId = "100";
 649         expectedException.expect(BuilderException.class);
 650         expectedException.expectMessage("Operational policy " + unknownPolicyId + " does not exist");
 651
 652         builder.setPolicyForPolicyResult(unknownPolicyId, triggerPolicy.getId(), PolicyResult.FAILURE);
 653     }
 654
 655     @Test
 656     public void testAddOperationsAccumulateParams() throws BuilderException {
 657         ControlLoopPolicyBuilder builder =
 658                         ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 659         Policy triggerPolicy =
 660                 builder.setTriggerPolicy(
 661                         PolicyParam.builder()
 662                         .id(UUID.randomUUID().toString())
 663                         .name("Restart the eNodeB")
 664                         .description("Upon getting the trigger event, restart the eNodeB")
 665                         .actor("RANController")
 666                         .target(new Target(TargetType.PNF))
 667                         .recipe(RESTART)
 668                         .payload(null)
 669                         .retries(2)
 670                         .timeout(300).build());
 671         //
 672         // Add the operationsAccumulateParams
 673         //
 674         triggerPolicy = builder.addOperationsAccumulateParams(triggerPolicy.getId(),
 675                 new OperationsAccumulateParams("15m", 5));
 676         assertNotNull(builder.getTriggerPolicy().getOperationsAccumulateParams());
 677         assertEquals("15m", builder.getTriggerPolicy().getOperationsAccumulateParams().getPeriod());
 678         assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getLimit() == 5);
 679     }
 680
 681
 682     @Test
 683     public void testBuildSpecification() throws BuilderException {
 684         //
 685         // Create the builder
 686         //
 687         ControlLoopPolicyBuilder builder =
 688                 ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 800);
 689         //
 690         // Set the first invalid trigger policy
 691         //
 692         final Policy policy1 = builder.setTriggerPolicy(
 693                 PolicyParam.builder()
 694                 .id(UUID.randomUUID().toString())
 695                 .name(RESTART_VM)
 696                 .description(TRIGGER_RESTART)
 697                 .actor(null)
 698                 .target(null)
 699                 .recipe(null)
 700                 .payload(null)
 701                 .retries(2)
 702                 .timeout(300).build());
 703         Results results = builder.buildSpecification();
 704         //
 705         // Check that ERRORs are in results for invalid policy arguments
 706         //
 707         boolean invalidActor = false;
 708         boolean invalidRecipe = false;
 709         boolean invalidTarget = false;
 710         for (Message m : results.getMessages()) {
 711             if ("Policy actor is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
 712                 invalidActor = true;
 713             }
 714             if ("Policy recipe is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
 715                 invalidRecipe = true;
 716             }
 717             if ("Policy target is null".equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
 718                 invalidTarget = true;
 719             }
 720         }
 721         //
 722         assertTrue(invalidActor);
 723         assertTrue(invalidRecipe);
 724         assertTrue(invalidTarget);
 725         //
 726         // Remove the invalid policy
 727         //
 728         // @SuppressWarnings("unused")
 729         boolean removed = builder.removePolicy(policy1.getId());
 730         assertTrue(removed);
 731         assertTrue(builder.getTriggerPolicy() == null);
 732         //
 733         // Set a valid trigger policy
 734         //
 735         Policy policy1a = builder.setTriggerPolicy(
 736                 PolicyParam.builder()
 737                 .id(UUID.randomUUID().toString())
 738                 .name(REBUILD_VM)
 739                 .description(REBUILD_RESTART)
 740                 .actor("APPC")
 741                 .target(new Target(TargetType.VM))
 742                 .recipe(REBUILD)
 743                 .payload(null)
 744                 .retries(1)
 745                 .timeout(600).build());
 746         //
 747         // Set a second valid trigger policy
 748         //
 749         final Policy policy2 =
 750                 builder.setTriggerPolicy(
 751                         PolicyParam.builder()
 752                         .id(UUID.randomUUID().toString())
 753                         .name(RESTART_VM)
 754                         .description(TRIGGER_RESTART)
 755                         .actor("APPC")
 756                         .target(new Target(TargetType.VM))
 757                         .recipe(RESTART)
 758                         .payload(null)
 759                         .retries(2)
 760                         .timeout(300).build());
 761         //
 762         // Now, we have policy1 unreachable
 763         //
 764         results = builder.buildSpecification();
 765         boolean unreachable = false;
 766         for (Message m : results.getMessages()) {
 767             if (m.getMessage().equals("Policy " + policy1a.getId() + " is not reachable.")
 768                     && m.getLevel() == MessageLevel.WARNING) {
 769                 unreachable = true;
 770                 break;
 771             }
 772         }
 773         assertTrue(unreachable);
 774         //
 775         // Set policy1a for the failure results of policy2
 776         //
 777         policy1a = builder.setPolicyForPolicyResult(policy1a.getId(), policy2.getId(), PolicyResult.FAILURE,
 778                 PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
 779         results = builder.buildSpecification();
 780         boolean invalidTimeout = false;
 781         for (Message m : results.getMessages()) {
 782             if ("controlLoop overall timeout is less than the sum of operational policy timeouts."
 783                             .equals(m.getMessage()) && m.getLevel() == MessageLevel.ERROR) {
 784                 invalidTimeout = true;
 785                 break;
 786             }
 787         }
 788         assertTrue(invalidTimeout);
 789         //
 790         // Remove policy2 (revert controlLoop back to open loop)
 791         //
 792         removed = builder.removePolicy(policy2.getId());
 793         //
 794         // ControlLoop is open loop now, but it still has policies (policy1)
 795         //
 796         results = builder.buildSpecification();
 797         unreachable = false;
 798         for (Message m : results.getMessages()) {
 799             if ("Open Loop policy contains policies. The policies will never be invoked.".equals(m.getMessage())
 800                     && m.getLevel() == MessageLevel.WARNING) {
 801                 unreachable = true;
 802                 break;
 803             }
 804         }
 805         assertTrue(unreachable);
 806     }
 807
 808
 809     @Test
 810     public void test1() throws Exception {
 811         this.test("src/test/resources/v1.0.0/policy_Test.yaml");
 812     }
 813
 814     @Test
 815     public void testEvilYaml() throws Exception {
 816         try (InputStream is = new FileInputStream(new File("src/test/resources/v1.0.0/test_evil.yaml"))) {
 817             //
 818             // Attempt to read the yaml into our Java Object
 819             //
 820             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 821             assertThatThrownBy(() -> yaml.load(is)).isInstanceOf(YAMLException.class);
 822         }
 823     }
 824
 825     /**
 826      * Does the actual test.
 827      *
 828      * @param testFile input file
 829      * @throws Exception if an error occurs
 830      */
 831     public void test(String testFile) throws Exception {
 832         try (InputStream is = new FileInputStream(new File(testFile))) {
 833             //
 834             // Read the yaml into our Java Object
 835             //
 836             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 837             Object obj = yaml.load(is);
 838             assertNotNull(obj);
 839             assertTrue(obj instanceof ControlLoopPolicy);
 840             ControlLoopPolicy policyTobuild = (ControlLoopPolicy) obj;
 841             //
 842             // Now we're going to try to use the builder to build this.
 843             //
 844             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(
 845                     policyTobuild.getControlLoop().getControlLoopName(), policyTobuild.getControlLoop().getTimeout());
 846             //
 847             // Add services
 848             //
 849             if (policyTobuild.getControlLoop().getServices() != null) {
 850                 builder = builder.addService(policyTobuild.getControlLoop().getServices()
 851                         .toArray(new Service[policyTobuild.getControlLoop().getServices().size()]));
 852             }
 853             //
 854             // Add resources
 855             //
 856             if (policyTobuild.getControlLoop().getResources() != null) {
 857                 builder = builder.addResource(policyTobuild.getControlLoop().getResources()
 858                         .toArray(new Resource[policyTobuild.getControlLoop().getResources().size()]));
 859             }
 860             //
 861             // Set pnf
 862             //
 863             if (policyTobuild.getControlLoop().getPnf() != null) {
 864                 builder = builder.setPnf(policyTobuild.getControlLoop().getPnf());
 865             }
 866             //
 867             // Add the policies and be sure to set the trigger policy
 868             //
 869             if (policyTobuild.getPolicies() != null) {
 870                 setTriggerPolicies(policyTobuild, builder);
 871             }
 872
 873             // Question : how to change policy ID and results by using builder ??
 874
 875             @SuppressWarnings("unused")
 876             Results results = builder.buildSpecification();
 877         }
 878
 879     }
 880
 881     private void setTriggerPolicies(ControlLoopPolicy policyTobuild, ControlLoopPolicyBuilder builder)
 882                     throws BuilderException {
 883         for (Policy policy : policyTobuild.getPolicies()) {
 884             if (policy.getId() == policyTobuild.getControlLoop().getTrigger_policy()) {
 885                 builder.setTriggerPolicy(
 886                         PolicyParam.builder()
 887                         .id(UUID.randomUUID().toString())
 888                         .name(policy.getName())
 889                         .description(policy.getDescription())
 890                         .actor(policy.getActor())
 891                         .target(policy.getTarget())
 892                         .recipe(policy.getRecipe())
 893                         .payload(null)
 894                         .retries(policy.getRetry())
 895                         .timeout(policy.getTimeout()).build());
 896             }
 897         }
 898     }
 899
 900 }