gerrit.onap Code Review - policy/drools-applications.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * policy-yaml unit test
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.controlloop.policy;
  22
  23 import static org.junit.Assert.assertFalse;
  24 import static org.junit.Assert.assertNotNull;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.junit.Assert.fail;
  27
  28 import java.io.File;
  29 import java.io.FileInputStream;
  30 import java.io.FileNotFoundException;
  31 import java.io.IOException;
  32 import java.io.InputStream;
  33 import java.util.UUID;
  34
  35 import org.junit.Test;
  36 import org.onap.policy.controlloop.policy.builder.BuilderException;
  37 import org.onap.policy.controlloop.policy.builder.ControlLoopPolicyBuilder;
  38 import org.onap.policy.controlloop.policy.builder.Message;
  39 import org.onap.policy.controlloop.policy.builder.MessageLevel;
  40 import org.onap.policy.controlloop.policy.builder.Results;
  41 import org.onap.policy.sdc.Resource;
  42 import org.onap.policy.sdc.ResourceType;
  43 import org.onap.policy.sdc.Service;
  44 import org.yaml.snakeyaml.Yaml;
  45 import org.yaml.snakeyaml.constructor.Constructor;
  46 import org.yaml.snakeyaml.error.YAMLException;
  47
  48
  49 public class ControlLoopPolicyBuilderTest {
  50
  51     @Test
  52     public void testControlLoop() {
  53         try {
  54             //
  55             // Create a builder for our policy
  56             //
  57             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
  58             //
  59             // Test add services
  60             //
  61             Service vSCP = new Service("vSCP");
  62             Service vUSP = new Service("vUSP");
  63             Service vTrinity = new Service("Trinity");
  64             builder = builder.addService(vSCP, vUSP, vTrinity);
  65             assertTrue(builder.getControlLoop().getServices().size() == 3);
  66             //
  67             // Test remove services
  68             //
  69             builder = builder.removeService(vSCP);
  70             assertTrue(builder.getControlLoop().getServices().size() == 2);
  71             builder = builder.removeAllServices();
  72             assertTrue(builder.getControlLoop().getServices().size() == 0);
  73             //
  74             // Test add resources
  75             //
  76             Resource vCTS = new Resource("vCTS", ResourceType.VF);
  77             Resource vCOM = new Resource("vCTS", ResourceType.VF);
  78             Resource vRAR = new Resource("vCTS", ResourceType.VF);
  79             builder = builder.addResource(vCTS, vCOM, vRAR);
  80             assertTrue(builder.getControlLoop().getResources().size() == 3);
  81             //
  82             // Test remove resources
  83             //
  84             builder = builder.removeResource(vCTS);
  85             assertTrue(builder.getControlLoop().getResources().size() == 2);
  86             builder = builder.removeAllResources();
  87             assertTrue(builder.getControlLoop().getResources().size() == 0);
  88             //
  89             // Test set abatement
  90             //
  91             assertFalse(builder.getControlLoop().getAbatement());
  92             builder = builder.setAbatement(true);
  93             assertTrue(builder.getControlLoop().getAbatement());
  94         } catch (BuilderException e) {
  95             fail(e.getMessage());
  96         }
  97     }
  98
  99     @Test
 100     public void testTimeout() {
 101         try {
 102             //
 103             // Create a builder for our policy
 104             //
 105             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 106             //
 107             // Test setTimeout
 108             //
 109             assertTrue(builder.getControlLoop().getTimeout() == 2400);
 110             builder = builder.setTimeout(800);
 111             assertTrue(builder.getControlLoop().getTimeout() == 800);
 112             //
 113             // Test calculateTimeout
 114             //
 115             Policy trigger = builder.setTriggerPolicy(
 116                     "Restart the VM",
 117                     "Upon getting the trigger event, restart the VM",
 118                     "APPC",
 119                     new Target(TargetType.VM),
 120                     "Restart",
 121                     null,
 122                     2,
 123                     300);
 124             @SuppressWarnings("unused")
 125             Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
 126                     "Rebuild VM",
 127                     "If the restart fails, rebuild it",
 128                     "APPC",
 129                     new Target(TargetType.VM),
 130                     "Rebuild",
 131                     null,
 132                     1,
 133                     600,
 134                     trigger.getId(),
 135                     PolicyResult.FAILURE,
 136                     PolicyResult.FAILURE_RETRIES,
 137                     PolicyResult.FAILURE_TIMEOUT);
 138             assertTrue(builder.calculateTimeout().equals(new Integer(300 + 600)));
 139             //
 140         } catch (BuilderException e) {
 141             fail(e.getMessage());
 142         }
 143     }
 144
 145     @Test
 146     public void testTriggerPolicyMethods() {
 147         try {
 148             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 149             //
 150             // Test isOpenLoop
 151             //
 152             assertTrue(builder.isOpenLoop());
 153             //
 154             // Test set initial trigger policy
 155             //
 156             Policy triggerPolicy1 = builder.setTriggerPolicy(
 157                     "Restart the VM",
 158                     "Upon getting the trigger event, restart the VM",
 159                     "APPC",
 160                     new Target(TargetType.VM),
 161                     "Restart",
 162                     null,
 163                     2,
 164                     300);
 165             assertTrue(builder.isOpenLoop() == false);
 166             assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
 167             //
 168             // Set trigger policy to a new policy
 169             //
 170             @SuppressWarnings("unused")
 171             Policy triggerPolicy2 = builder.setTriggerPolicy(
 172                     "Rebuild the VM",
 173                     "Upon getting the trigger event, rebuild the VM",
 174                     "APPC",
 175                     new Target(TargetType.VM),
 176                     "Rebuild",
 177                     null,
 178                     2,
 179                     300);
 180             //
 181             // Test set trigger policy to another existing policy
 182             //
 183             @SuppressWarnings("unused")
 184             ControlLoop cl = builder.setTriggerPolicy(triggerPolicy1.getId());
 185             assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
 186             //
 187             // Test get trigger policy
 188             //
 189             assertTrue(builder.getTriggerPolicy().equals(triggerPolicy1));
 190             //
 191         } catch (BuilderException e) {
 192             fail(e.getMessage());
 193         }
 194     }
 195
 196     @Test
 197     public void testAddRemovePolicies() {
 198         try {
 199             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 200             Policy triggerPolicy = builder.setTriggerPolicy(
 201                     "Restart the VM",
 202                     "Upon getting the trigger event, restart the VM",
 203                     "APPC",
 204                     new Target(TargetType.VM),
 205                     "Restart",
 206                     null,
 207                     2,
 208                     300);
 209             //
 210             // Test create a policy and chain it to the results of trigger policy
 211             //
 212             Policy onRestartFailurePolicy1 = builder.setPolicyForPolicyResult(
 213                     "Rebuild VM",
 214                     "If the restart fails, rebuild it.",
 215                     "APPC",
 216                     new Target(TargetType.VM),
 217                     "Rebuild",
 218                     null,
 219                     1,
 220                     600,
 221                     triggerPolicy.getId(),
 222                     PolicyResult.FAILURE,
 223                     PolicyResult.FAILURE_RETRIES,
 224                     PolicyResult.FAILURE_TIMEOUT,
 225                     PolicyResult.FAILURE_GUARD);
 226             //
 227             assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy1.getId()));
 228             assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy1.getId()));
 229             assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy1.getId()));
 230             assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy1.getId()));
 231             //
 232             // Test remove policy
 233             //
 234             boolean removed = builder.removePolicy(onRestartFailurePolicy1.getId());
 235             assertTrue(removed);
 236             assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 237             assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 238             assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 239             assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString()));
 240             //
 241             // Create another policy and chain it to the results of trigger policy
 242             //
 243             Policy onRestartFailurePolicy2 = builder.setPolicyForPolicyResult(
 244                     "Rebuild VM",
 245                     "If the restart fails, rebuild it.",
 246                     "APPC",
 247                     new Target(TargetType.VM),
 248                     "Rebuild",
 249                     null,
 250                     2,
 251                     600,
 252                     triggerPolicy.getId(),
 253                     PolicyResult.FAILURE,
 254                     PolicyResult.FAILURE_RETRIES,
 255                     PolicyResult.FAILURE_TIMEOUT);
 256             //
 257             // Test reset policy results
 258             //
 259             triggerPolicy = builder.resetPolicyResults(triggerPolicy.getId());
 260             assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
 261             assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
 262             assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
 263             //
 264             // Test set the policy results to an existing operational policy
 265             //
 266             onRestartFailurePolicy2 = builder.setPolicyForPolicyResult(
 267                     onRestartFailurePolicy2.getId(),
 268                     triggerPolicy.getId(),
 269                     PolicyResult.FAILURE,
 270                     PolicyResult.FAILURE_RETRIES,
 271                     PolicyResult.FAILURE_TIMEOUT);
 272             assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy2.getId()));
 273             assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy2.getId()));
 274             assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy2.getId()));
 275
 276             //
 277             // Test remove all existing operational policies
 278             //
 279             builder = builder.removeAllPolicies();
 280             assertTrue(builder.getControlLoop().getTrigger_policy().equals(FinalResult.FINAL_OPENLOOP.toString()));
 281             //
 282         } catch (BuilderException e) {
 283             fail(e.getMessage());
 284         }
 285     }
 286
 287     @Test
 288     public void testAddOperationsAccumulateParams() {
 289         try {
 290             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
 291             Policy triggerPolicy = builder.setTriggerPolicy(
 292                     "Restart the eNodeB",
 293                     "Upon getting the trigger event, restart the eNodeB",
 294                     "RANController",
 295                     new Target(TargetType.PNF),
 296                     "Restart",
 297                     null,
 298                     2,
 299                     300);
 300             //
 301             // Add the operationsAccumulateParams
 302             //
 303             triggerPolicy = builder.addOperationsAccumulateParams(triggerPolicy.getId(), new OperationsAccumulateParams("15m", 5));
 304             assertNotNull(builder.getTriggerPolicy().getOperationsAccumulateParams());
 305             assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getPeriod().equals("15m"));
 306             assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getLimit() == 5);
 307             //
 308         } catch (BuilderException e) {
 309             fail(e.getMessage());
 310         }
 311     }
 312
 313
 314     @Test
 315     public void testBuildSpecification() {
 316         try {
 317             //
 318             // Create the builder
 319             //
 320             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 800);
 321             //
 322             // Set the first invalid trigger policy
 323             //
 324             Policy policy1 = builder.setTriggerPolicy(
 325                     "Restart the VM",
 326                     "Upon getting the trigger event, restart the VM",
 327                     null,
 328                     null,
 329                     "Instantiate",
 330                     null,
 331                     2,
 332                     300);
 333             Results results = builder.buildSpecification();
 334             //
 335             // Check that ERRORs are in results for invalid policy arguments
 336             //
 337             boolean invalid_actor = false;
 338             boolean invalid_recipe = false;
 339             boolean invalid_target = false;
 340             for (Message m : results.getMessages()) {
 341                 if (m.getMessage().equals("Policy actor is null") && m.getLevel() == MessageLevel.ERROR) {
 342                     invalid_actor = true;
 343                 }
 344                 if (m.getMessage().equals("Policy recipe is invalid") && m.getLevel() == MessageLevel.ERROR) {
 345                     invalid_recipe = true;
 346                 }
 347                 if (m.getMessage().equals("Policy target is null") && m.getLevel() == MessageLevel.ERROR) {
 348                     invalid_target = true;
 349                 }
 350             }
 351             //
 352             assertTrue(invalid_actor);
 353             assertTrue(invalid_recipe);
 354             assertTrue(invalid_target);
 355             //
 356             // Remove the invalid policy
 357             //
 358             //@SuppressWarnings("unused")
 359             boolean removed = builder.removePolicy(policy1.getId());
 360             assertTrue(removed);
 361             assertTrue(builder.getTriggerPolicy() == null);
 362             //
 363             // Set a valid trigger policy
 364             //
 365             policy1 = builder.setTriggerPolicy(
 366                     "Rebuild VM",
 367                     "If the restart fails, rebuild it.",
 368                     "APPC",
 369                     new Target(TargetType.VM),
 370                     "Rebuild",
 371                     null,
 372                     1,
 373                     600);
 374             //
 375             // Set a second valid trigger policy
 376             //
 377             Policy policy2 = builder.setTriggerPolicy(
 378                     "Restart the VM",
 379                     "Upon getting the trigger event, restart the VM",
 380                     "APPC",
 381                     new Target(TargetType.VM),
 382                     "Restart",
 383                     null,
 384                     2,
 385                     300);
 386             //
 387             // Now, we have policy1 unreachable
 388             //
 389             results = builder.buildSpecification();
 390             boolean unreachable = false;
 391             for (Message m : results.getMessages()) {
 392                 if (m.getMessage().equals("Policy " + policy1.getId() + " is not reachable.") && m.getLevel() == MessageLevel.WARNING) {
 393                     unreachable = true;
 394                     break;
 395                 }
 396             }
 397             assertTrue(unreachable);
 398             //
 399             // Set policy1 for the failure results of policy2
 400             //
 401             policy1 = builder.setPolicyForPolicyResult(
 402                     policy1.getId(),
 403                     policy2.getId(),
 404                     PolicyResult.FAILURE,
 405                     PolicyResult.FAILURE_RETRIES,
 406                     PolicyResult.FAILURE_TIMEOUT);
 407             results = builder.buildSpecification();
 408             boolean invalid_timeout = false;
 409             for (Message m : results.getMessages()) {
 410                 if (m.getMessage().equals("controlLoop overall timeout is less than the sum of operational policy timeouts.") && m.getLevel() == MessageLevel.ERROR) {
 411                     invalid_timeout = true;
 412                     break;
 413                 }
 414             }
 415             assertTrue(invalid_timeout);
 416             //
 417             // Remove policy2 (revert controlLoop back to open loop)
 418             //
 419             removed = builder.removePolicy(policy2.getId());
 420             //
 421             // ControlLoop is open loop now, but it still has policies (policy1)
 422             //
 423             results = builder.buildSpecification();
 424             unreachable = false;
 425             for (Message m : results.getMessages()) {
 426                 if (m.getMessage().equals("Open Loop policy contains policies. The policies will never be invoked.") && m.getLevel() == MessageLevel.WARNING) {
 427                     unreachable = true;
 428                     break;
 429                 }
 430             }
 431             assertTrue(unreachable);
 432             //
 433         } catch (BuilderException e) {
 434             fail(e.getMessage());
 435         }
 436     }
 437
 438
 439     @Test
 440     public void test() {
 441         this.test("src/test/resources/v1.0.0/policy_Test.yaml");
 442     }
 443
 444     @Test
 445     public void testEvilYaml() {
 446         try (InputStream is = new FileInputStream(new File("src/test/resources/v1.0.0/test_evil.yaml"))) {
 447             //
 448             // Read the yaml into our Java Object
 449             //
 450             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 451             yaml.load(is);
 452         } catch (FileNotFoundException e) {
 453             fail(e.getLocalizedMessage());
 454         } catch (IOException e) {
 455             fail(e.getLocalizedMessage());
 456         } catch (YAMLException e) {
 457             //
 458             // Should have this
 459             //
 460         }
 461     }
 462
 463     public void test(String testFile) {
 464         try (InputStream is = new FileInputStream(new File(testFile))) {
 465             //
 466             // Read the yaml into our Java Object
 467             //
 468             Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
 469             Object obj = yaml.load(is);
 470             assertNotNull(obj);
 471             assertTrue(obj instanceof ControlLoopPolicy);
 472             ControlLoopPolicy policyTobuild = (ControlLoopPolicy) obj;
 473             //
 474             // Now we're going to try to use the builder to build this.
 475             //
 476             ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(
 477                     policyTobuild.getControlLoop().getControlLoopName(),
 478                     policyTobuild.getControlLoop().getTimeout());
 479             //
 480             // Add services
 481             //
 482             if (policyTobuild.getControlLoop().getServices() != null) {
 483                 builder = builder.addService(policyTobuild.getControlLoop().getServices().toArray(new Service[policyTobuild.getControlLoop().getServices().size()]));
 484             }
 485             //
 486             // Add resources
 487             //
 488             if (policyTobuild.getControlLoop().getResources() != null) {
 489                 builder = builder.addResource(policyTobuild.getControlLoop().getResources().toArray(new Resource[policyTobuild.getControlLoop().getResources().size()]));
 490             }
 491             //
 492             // Set pnf
 493             //
 494             if (policyTobuild.getControlLoop().getPnf() != null) {
 495                 builder = builder.setPNF(policyTobuild.getControlLoop().getPnf());
 496             }
 497             //
 498             // Add the policies and be sure to set the trigger policy
 499             //
 500             if (policyTobuild.getPolicies() != null) {
 501                 for (Policy policy : policyTobuild.getPolicies()) {
 502                     if (policy.getId() == policyTobuild.getControlLoop().getTrigger_policy()) {
 503                         builder.setTriggerPolicy(policy.getName(), policy.getDescription(), policy.getActor(), policy.getTarget(), policy.getRecipe(), null, policy.getRetry(), policy.getTimeout());
 504                     }
 505                 }
 506             }
 507
 508             // Question : how to change policy ID and results by using builder ??
 509
 510             @SuppressWarnings("unused")
 511             Results results = builder.buildSpecification();
 512
 513         } catch (FileNotFoundException e) {
 514             fail(e.getLocalizedMessage());
 515         } catch (IOException e) {
 516             fail(e.getLocalizedMessage());
 517         } catch (BuilderException e) {
 518             fail(e.getLocalizedMessage());
 519         }
 520
 521     }
 522
 523 }