gerrit.onap Code Review - policy/models.git/blob

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