ECOMP-ControlloopPolicy/src/test/java/org/openecomp/policy/controlloop/policy/ControlLoopPolicyBuilderTest.java

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