controlloop/common/controller-usecases/src/test/java/org/onap/policy/drools/apps/controller/usecases/UsecasesEventManagerTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2020-2021 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.drools.apps.controller.usecases;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.assertj.core.api.Assertions.assertThatCode;
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertFalse;
  28 import static org.junit.Assert.assertNotNull;
  29 import static org.junit.Assert.assertSame;
  30 import static org.junit.Assert.assertTrue;
  31 import static org.mockito.ArgumentMatchers.any;
  32 import static org.mockito.Mockito.verify;
  33 import static org.mockito.Mockito.when;
  34
  35 import java.time.Instant;
  36 import java.util.ArrayList;
  37 import java.util.Arrays;
  38 import java.util.Deque;
  39 import java.util.List;
  40 import java.util.Map;
  41 import java.util.TreeMap;
  42 import java.util.UUID;
  43 import java.util.concurrent.ExecutorService;
  44 import org.drools.core.WorkingMemory;
  45 import org.junit.Before;
  46 import org.junit.Test;
  47 import org.junit.runner.RunWith;
  48 import org.kie.api.runtime.rule.FactHandle;
  49 import org.mockito.Mock;
  50 import org.mockito.junit.MockitoJUnitRunner;
  51 import org.onap.policy.common.utils.coder.Coder;
  52 import org.onap.policy.common.utils.coder.CoderException;
  53 import org.onap.policy.common.utils.coder.StandardYamlCoder;
  54 import org.onap.policy.common.utils.resources.ResourceUtils;
  55 import org.onap.policy.controlloop.ControlLoopEventStatus;
  56 import org.onap.policy.controlloop.ControlLoopException;
  57 import org.onap.policy.controlloop.ControlLoopResponse;
  58 import org.onap.policy.controlloop.ControlLoopTargetType;
  59 import org.onap.policy.controlloop.VirtualControlLoopEvent;
  60 import org.onap.policy.controlloop.actorserviceprovider.ActorService;
  61 import org.onap.policy.controlloop.actorserviceprovider.Operation;
  62 import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
  63 import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
  64 import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
  65 import org.onap.policy.controlloop.actorserviceprovider.Operator;
  66 import org.onap.policy.controlloop.actorserviceprovider.TargetType;
  67 import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
  68 import org.onap.policy.controlloop.actorserviceprovider.spi.Actor;
  69 import org.onap.policy.controlloop.drl.legacy.ControlLoopParams;
  70 import org.onap.policy.controlloop.eventmanager.ActorConstants;
  71 import org.onap.policy.controlloop.ophistory.OperationHistoryDataManager;
  72 import org.onap.policy.drools.apps.controller.usecases.step.AaiCqStep2;
  73 import org.onap.policy.drools.apps.controller.usecases.step.AaiGetPnfStep2;
  74 import org.onap.policy.drools.apps.controller.usecases.step.AaiGetTenantStep2;
  75 import org.onap.policy.drools.apps.controller.usecases.step.GetTargetEntityStep2;
  76 import org.onap.policy.drools.apps.controller.usecases.step.GuardStep2;
  77 import org.onap.policy.drools.apps.controller.usecases.step.Step2;
  78 import org.onap.policy.drools.core.lock.LockCallback;
  79 import org.onap.policy.drools.core.lock.LockImpl;
  80 import org.onap.policy.drools.core.lock.LockState;
  81 import org.onap.policy.drools.system.PolicyEngine;
  82 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  83 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  84 import org.onap.policy.sdnr.PciBody;
  85 import org.onap.policy.sdnr.PciMessage;
  86 import org.onap.policy.sdnr.PciResponse;
  87
  88 @RunWith(MockitoJUnitRunner.class)
  89 public class UsecasesEventManagerTest {
  90     private static final UUID REQ_ID = UUID.randomUUID();
  91     private static final String CL_NAME = "my-closed-loop-name";
  92     private static final String POLICY_NAME = "my-policy-name";
  93     private static final String POLICY_SCOPE = "my-scope";
  94     private static final String POLICY_VERSION = "1.2.3";
  95     private static final String SIMPLE_ACTOR = "First";
  96     private static final String SIMPLE_OPERATION = "OperationA";
  97     private static final String MY_TARGET = "my-target";
  98     private static final String EVENT_MGR_SIMPLE_YAML =
  99                     "../eventmanager/src/test/resources/eventManager/event-mgr-simple.yaml";
 100     private static final Coder yamlCoder = new StandardYamlCoder();
 101     private static final String OUTCOME_MSG = "my outcome message";
 102
 103     @Mock
 104     private PolicyEngine engineMgr;
 105     @Mock
 106     private WorkingMemory workMem;
 107     @Mock
 108     private FactHandle factHandle;
 109     @Mock
 110     private Operator policyOperator;
 111     @Mock
 112     private Operation policyOperation;
 113     @Mock
 114     private Actor policyActor;
 115     @Mock
 116     private ActorService actors;
 117     @Mock
 118     private OperationHistoryDataManager dataMgr;
 119     @Mock
 120     private ExecutorService executor;
 121     @Mock
 122     private Step2 stepa;
 123     @Mock
 124     private Step2 stepb;
 125
 126     private List<LockImpl> locks;
 127     private ToscaPolicy tosca;
 128     private ControlLoopParams params;
 129     private VirtualControlLoopEvent event;
 130     private UsecasesEventManager mgr;
 131
 132     /**
 133      * Sets up.
 134      */
 135     @Before
 136     public void setUp() throws ControlLoopException, CoderException {
 137         when(workMem.getFactHandle(any())).thenReturn(factHandle);
 138
 139         event = new VirtualControlLoopEvent();
 140         event.setRequestId(REQ_ID);
 141         event.setTarget(UsecasesConstants.VSERVER_VSERVER_NAME);
 142         event.setAai(new TreeMap<>(Map.of(UsecasesConstants.VSERVER_VSERVER_NAME, MY_TARGET)));
 143         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 144         event.setClosedLoopControlName(CL_NAME);
 145         event.setTargetType(ControlLoopTargetType.VNF);
 146
 147         params = new ControlLoopParams();
 148         params.setClosedLoopControlName(CL_NAME);
 149         params.setPolicyName(POLICY_NAME);
 150         params.setPolicyScope(POLICY_SCOPE);
 151         params.setPolicyVersion(POLICY_VERSION);
 152
 153         loadPolicy(EVENT_MGR_SIMPLE_YAML);
 154
 155         locks = new ArrayList<>();
 156
 157         mgr = new MyManager(params, event, workMem);
 158     }
 159
 160     @Test
 161     public void testConstructor() {
 162         assertEquals(POLICY_NAME, mgr.getPolicyName());
 163         assertSame(event, mgr.getEvent());
 164
 165         Map<String, String> orig = event.getAai();
 166
 167         event.setAai(addAai(orig, UsecasesConstants.VSERVER_IS_CLOSED_LOOP_DISABLED, "true"));
 168         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 169                         .hasMessage("is-closed-loop-disabled is set to true on VServer or VNF");
 170
 171         // vserver ACTIVE
 172         event.setAai(addAai(orig, UsecasesConstants.VSERVER_PROV_STATUS,
 173                         UsecasesConstants.PROV_STATUS_ACTIVE.toUpperCase()));
 174         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 175
 176         // vserver active
 177         event.setAai(addAai(orig, UsecasesConstants.VSERVER_PROV_STATUS,
 178                         UsecasesConstants.PROV_STATUS_ACTIVE.toLowerCase()));
 179         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 180
 181         // vserver inactive
 182         event.setAai(addAai(orig, UsecasesConstants.VSERVER_PROV_STATUS, "inactive"));
 183         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 184                         .hasMessage("prov-status is not ACTIVE on VServer or VNF");
 185
 186         // vnf ACTIVE
 187         event.setAai(addAai(orig, UsecasesConstants.GENERIC_VNF_PROV_STATUS,
 188                         UsecasesConstants.PROV_STATUS_ACTIVE.toUpperCase()));
 189         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 190
 191         // vnf active
 192         event.setAai(addAai(orig, UsecasesConstants.GENERIC_VNF_PROV_STATUS,
 193                         UsecasesConstants.PROV_STATUS_ACTIVE.toLowerCase()));
 194         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 195
 196         // vnf inactive
 197         event.setAai(addAai(orig, UsecasesConstants.GENERIC_VNF_PROV_STATUS, "inactive"));
 198         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 199                         .hasMessage("prov-status is not ACTIVE on VServer or VNF");
 200
 201         // valid
 202         event.setAai(orig);
 203         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 204
 205         // invalid
 206         event.setTarget("unknown-target");
 207         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 208                         .isInstanceOf(ControlLoopException.class);
 209     }
 210
 211     @Test
 212     public void testLoadPreprocessorSteps() {
 213         stepa = new Step2(mgr, ControlLoopOperationParams.builder().build(), event) {
 214             @Override
 215             public List<String> getPropertyNames() {
 216                 return List.of(OperationProperties.AAI_DEFAULT_CLOUD_REGION);
 217             }
 218
 219             @Override
 220             protected Operation buildOperation() {
 221                 return policyOperation;
 222             }
 223         };
 224
 225         mgr.getSteps().add(stepa);
 226         mgr.getSteps().add(stepb);
 227
 228         mgr.loadPreprocessorSteps();
 229
 230         Deque<Step2> steps = mgr.getSteps();
 231
 232         Step2 lockStep = steps.poll();
 233         assertNotNull(lockStep);
 234         assertEquals(ActorConstants.LOCK_ACTOR, lockStep.getActorName());
 235         assertThat(steps.poll()).isInstanceOf(AaiCqStep2.class);
 236         assertThat(steps.poll()).isInstanceOf(GuardStep2.class);
 237         assertSame(stepa, steps.poll());
 238         assertSame(stepb, steps.poll());
 239         assertThat(steps).isEmpty();
 240     }
 241
 242     /**
 243      * Tests loadPreprocessorSteps() when no additional steps are needed.
 244      */
 245     @Test
 246     public void testLoadPreprocessorStepsNothingToLoad() {
 247         when(stepa.isPolicyStep()).thenReturn(false);
 248         when(stepa.getPropertyNames()).thenReturn(List.of("unknown-property"));
 249
 250         Deque<Step2> steps = mgr.getSteps();
 251         steps.add(stepa);
 252         steps.add(stepb);
 253
 254         setTargetEntity();
 255         mgr.loadPreprocessorSteps();
 256
 257         assertSame(stepa, steps.poll());
 258         assertSame(stepb, steps.poll());
 259         assertThat(steps).isEmpty();
 260     }
 261
 262     /**
 263      * Tests loadPreprocessorSteps() when an A&AI custom query is needed.
 264      */
 265     @Test
 266     public void testLoadPreprocessorStepsCq() {
 267         loadStepsWithProperties(OperationProperties.AAI_DEFAULT_CLOUD_REGION, OperationProperties.AAI_DEFAULT_TENANT);
 268
 269         setTargetEntity();
 270         mgr.loadPreprocessorSteps();
 271
 272         Deque<Step2> steps = mgr.getSteps();
 273
 274         assertThat(steps.poll()).isInstanceOf(AaiCqStep2.class);
 275         assertSame(stepa, steps.poll());
 276         assertSame(stepb, steps.poll());
 277         assertThat(steps).isEmpty();
 278     }
 279
 280     /**
 281      * Tests loadPreprocessorSteps() when an A&AI PNF query is needed.
 282      */
 283     @Test
 284     public void testLoadPreprocessorStepsPnf() {
 285         // doubling up the property to check both branches
 286         loadStepsWithProperties(OperationProperties.AAI_PNF, OperationProperties.AAI_PNF);
 287
 288         setTargetEntity();
 289         mgr.loadPreprocessorSteps();
 290
 291         Deque<Step2> steps = mgr.getSteps();
 292
 293         assertThat(steps.poll()).isInstanceOf(AaiGetPnfStep2.class);
 294         assertSame(stepa, steps.poll());
 295         assertSame(stepb, steps.poll());
 296         assertThat(steps).isEmpty();
 297     }
 298
 299     /**
 300      * Tests loadPreprocessorSteps() when an A&AI Tenant query is needed.
 301      */
 302     @Test
 303     public void testLoadPreprocessorStepsTenant() {
 304         // doubling up the property to check both branches
 305         event.getAai().put(Step2.VSERVER_VSERVER_NAME, "my-vserver");
 306         loadStepsWithProperties(OperationProperties.AAI_VSERVER_LINK, OperationProperties.AAI_VSERVER_LINK);
 307
 308         setTargetEntity();
 309         mgr.loadPreprocessorSteps();
 310
 311         Deque<Step2> steps = mgr.getSteps();
 312
 313         assertThat(steps.poll()).isInstanceOf(AaiGetTenantStep2.class);
 314         assertSame(stepa, steps.poll());
 315         assertSame(stepb, steps.poll());
 316         assertThat(steps).isEmpty();
 317     }
 318
 319     /**
 320      * Tests loadPreprocessorSteps() when the target entity is unset.
 321      */
 322     @Test
 323     public void testLoadPreprocessorStepsNeedTargetEntity() {
 324         stepa = new Step2(mgr, ControlLoopOperationParams.builder()
 325                         .targetType(TargetType.toTargetType(event.getTargetType())).targetEntityIds(Map.of()).build(),
 326                         event) {
 327             @Override
 328             public List<String> getPropertyNames() {
 329                 return List.of(OperationProperties.AAI_TARGET_ENTITY);
 330             }
 331
 332             @Override
 333             protected Operation buildOperation() {
 334                 return policyOperation;
 335             }
 336
 337             @Override
 338             public boolean isPolicyStep() {
 339                 return false;
 340             }
 341         };
 342
 343         Deque<Step2> steps = mgr.getSteps();
 344         steps.add(stepa);
 345         steps.add(stepb);
 346
 347         mgr.loadPreprocessorSteps();
 348
 349         Step2 entityStep = steps.poll();
 350
 351         assertThat(entityStep).isInstanceOf(GetTargetEntityStep2.class);
 352         assertSame(stepa, steps.poll());
 353         assertSame(stepb, steps.poll());
 354         assertThat(steps).isEmpty();
 355
 356         // put get-target-entity back onto the queue and ensure nothing else is added
 357         steps.add(entityStep);
 358         mgr.loadPreprocessorSteps();
 359         assertSame(entityStep, steps.poll());
 360         assertThat(steps).isEmpty();
 361     }
 362
 363     @Test
 364     public void testIsAbort() {
 365         OperationOutcome outcome = makeCompletedOutcome();
 366         outcome.setResult(OperationResult.FAILURE);
 367
 368         // closed loop timeout
 369         outcome.setActor(ActorConstants.CL_TIMEOUT_ACTOR);
 370         assertTrue(mgr.isAbort(outcome));
 371
 372         // lost lock
 373         outcome.setActor(ActorConstants.LOCK_ACTOR);
 374         assertTrue(mgr.isAbort(outcome));
 375
 376         // no effect for success
 377         outcome.setResult(OperationResult.SUCCESS);
 378         assertFalse(mgr.isAbort(outcome));
 379     }
 380
 381     @Test
 382     public void testStoreInDataBase() throws ControlLoopException {
 383         mgr.start();
 384         OperationOutcome outcome = makeOutcome();
 385         mgr.addToHistory(outcome);
 386
 387         mgr.storeInDataBase(mgr.getPartialHistory().peekLast());
 388
 389         verify(dataMgr).store(REQ_ID.toString(), event.getClosedLoopControlName(), event, null,
 390                         mgr.getPartialHistory().peekLast().getClOperation());
 391     }
 392
 393     @Test
 394     public void testMakeControlLoopResponse() {
 395         final OperationOutcome outcome = new OperationOutcome();
 396
 397         // no message - should return null
 398         checkResp(outcome, null);
 399
 400         // not a PciMessage - should return null
 401         outcome.setResponse("not-a-pci-message");
 402         checkResp(outcome, null);
 403
 404         /*
 405          * now work with a PciMessage
 406          */
 407         PciMessage msg = new PciMessage();
 408         outcome.setResponse(msg);
 409
 410         PciBody body = new PciBody();
 411         msg.setBody(body);
 412
 413         PciResponse output = new PciResponse();
 414         body.setOutput(output);
 415
 416         output.setPayload("my-payload");
 417
 418         // should generate a response, with a payload
 419         checkResp(outcome, "my-payload");
 420
 421         /*
 422          * these should generate a response, with null payload
 423          */
 424         output.setPayload(null);
 425         checkResp(outcome, null);
 426
 427         body.setOutput(null);
 428         checkResp(outcome, null);
 429
 430         msg.setBody(null);
 431         checkResp(outcome, null);
 432
 433         outcome.setResponse(null);
 434         checkResp(outcome, null);
 435     }
 436
 437     @Test
 438     public void testCheckEventSyntax() {
 439         /*
 440          * only need to check one success and one failure from the super class method
 441          */
 442
 443         // initially, it's valid
 444         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 445
 446         event.setTarget("unknown-target");
 447         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 448                         .hasMessage("target field invalid");
 449
 450         event.setTarget(null);
 451         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 452                         .hasMessage("No target field");
 453
 454         event.setRequestId(null);
 455         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 456                         .hasMessage("No request ID");
 457     }
 458
 459     @Test
 460     public void testValidateStatus() {
 461         /*
 462          * only need to check one success and one failure from the super class method
 463          */
 464         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 465         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 466
 467         event.setClosedLoopEventStatus(null);
 468         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 469                         .hasMessage("Invalid value in closedLoopEventStatus");
 470     }
 471
 472     @Test
 473     public void testValidateAaiData() {
 474         event.setTargetType("unknown-target-type");
 475         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 476                         .hasMessage("The target type is not supported");
 477
 478         event.setTargetType(null);
 479         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 480                         .hasMessage("The Target type is null");
 481
 482         event.setAai(null);
 483         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 484                         .hasMessage("AAI is null");
 485
 486         // VM case
 487         event.setTargetType(ControlLoopTargetType.VM);
 488         event.setAai(Map.of(UsecasesConstants.GENERIC_VNF_VNF_ID, MY_TARGET));
 489         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 490
 491         event.setAai(Map.of());
 492         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class);
 493
 494         // VNF case
 495         event.setTargetType(ControlLoopTargetType.VNF);
 496         event.setAai(Map.of(UsecasesConstants.GENERIC_VNF_VNF_ID, MY_TARGET));
 497         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 498
 499         event.setAai(Map.of());
 500         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class);
 501
 502         // PNF case
 503         event.setTargetType(ControlLoopTargetType.PNF);
 504         event.setAai(Map.of(UsecasesConstants.PNF_NAME, MY_TARGET));
 505         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 506
 507         event.setAai(Map.of());
 508         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class);
 509     }
 510
 511     @Test
 512     public void testValidateAaiVmVnfData() {
 513         event.setTargetType(ControlLoopTargetType.VM);
 514         event.setAai(Map.of(UsecasesConstants.GENERIC_VNF_VNF_ID, MY_TARGET));
 515         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 516
 517         event.setAai(Map.of(UsecasesConstants.VSERVER_VSERVER_NAME, MY_TARGET));
 518         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 519
 520         event.setAai(Map.of(UsecasesConstants.GENERIC_VNF_VNF_NAME, MY_TARGET));
 521         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 522
 523         event.setAai(Map.of());
 524         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class).hasMessage(
 525                         "generic-vnf.vnf-id or generic-vnf.vnf-name or vserver.vserver-name information missing");
 526     }
 527
 528     @Test
 529     public void testValidateAaiPnfData() {
 530         event.setTargetType(ControlLoopTargetType.PNF);
 531         event.setAai(Map.of(UsecasesConstants.PNF_NAME, MY_TARGET));
 532         assertThatCode(() -> mgr.checkEventSyntax(event)).doesNotThrowAnyException();
 533
 534         event.setAai(Map.of());
 535         assertThatCode(() -> mgr.checkEventSyntax(event)).isInstanceOf(ControlLoopException.class)
 536                         .hasMessage("AAI PNF object key pnf-name is missing");
 537     }
 538
 539     @Test
 540     public void testIsClosedLoopDisabled() {
 541         Map<String, String> orig = event.getAai();
 542
 543         event.setAai(addAai(orig, UsecasesConstants.VSERVER_IS_CLOSED_LOOP_DISABLED, "true"));
 544         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 545                         .isInstanceOf(IllegalStateException.class);
 546
 547         event.setAai(addAai(orig, UsecasesConstants.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED, "true"));
 548         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 549                         .isInstanceOf(IllegalStateException.class);
 550
 551         event.setAai(addAai(orig, UsecasesConstants.PNF_IS_IN_MAINT, "true"));
 552         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 553                         .isInstanceOf(IllegalStateException.class);
 554     }
 555
 556     @Test
 557     public void testIsProvStatusInactive() {
 558         Map<String, String> orig = event.getAai();
 559
 560         event.setAai(addAai(orig, UsecasesConstants.VSERVER_PROV_STATUS, "ACTIVE"));
 561         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 562
 563         event.setAai(addAai(orig, UsecasesConstants.VSERVER_PROV_STATUS, "inactive"));
 564         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 565                         .isInstanceOf(IllegalStateException.class);
 566
 567         event.setAai(addAai(orig, UsecasesConstants.GENERIC_VNF_PROV_STATUS, "ACTIVE"));
 568         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 569
 570         event.setAai(addAai(orig, UsecasesConstants.GENERIC_VNF_PROV_STATUS, "inactive"));
 571         assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 572                         .isInstanceOf(IllegalStateException.class);
 573     }
 574
 575     @Test
 576     public void testIsAaiTrue() {
 577         Map<String, String> orig = event.getAai();
 578
 579         for (String value : Arrays.asList("yes", "y", "true", "t", "yEs", "trUe")) {
 580             event.setAai(addAai(orig, UsecasesConstants.VSERVER_IS_CLOSED_LOOP_DISABLED, value));
 581             assertThatThrownBy(() -> new UsecasesEventManager(params, event, workMem))
 582                             .isInstanceOf(IllegalStateException.class);
 583         }
 584
 585         event.setAai(addAai(orig, UsecasesConstants.VSERVER_IS_CLOSED_LOOP_DISABLED, "false"));
 586         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 587
 588         event.setAai(addAai(orig, UsecasesConstants.VSERVER_IS_CLOSED_LOOP_DISABLED, "no"));
 589         assertThatCode(() -> new UsecasesEventManager(params, event, workMem)).doesNotThrowAnyException();
 590     }
 591
 592
 593
 594     private Map<String, String> addAai(Map<String, String> original, String key, String value) {
 595         Map<String, String> map = new TreeMap<>(original);
 596         map.put(key, value);
 597         return map;
 598     }
 599
 600     private void loadPolicy(String fileName) throws CoderException {
 601         ToscaServiceTemplate template =
 602                         yamlCoder.decode(ResourceUtils.getResourceAsString(fileName), ToscaServiceTemplate.class);
 603         tosca = template.getToscaTopologyTemplate().getPolicies().get(0).values().iterator().next();
 604
 605         params.setToscaPolicy(tosca);
 606     }
 607
 608     private void loadStepsWithProperties(String... properties) {
 609         stepa = new Step2(mgr, ControlLoopOperationParams.builder().build(), event) {
 610
 611             @Override
 612             public boolean isPolicyStep() {
 613                 return false;
 614             }
 615
 616             @Override
 617             public List<String> getPropertyNames() {
 618                 return List.of(properties);
 619             }
 620
 621             @Override
 622             protected Operation buildOperation() {
 623                 return policyOperation;
 624             }
 625         };
 626
 627         mgr.getSteps().add(stepa);
 628         mgr.getSteps().add(stepb);
 629     }
 630
 631     private OperationOutcome makeCompletedOutcome() {
 632         OperationOutcome outcome = makeOutcome();
 633         outcome.setEnd(outcome.getStart());
 634
 635         return outcome;
 636     }
 637
 638     private OperationOutcome makeOutcome() {
 639         OperationOutcome outcome = new OperationOutcome();
 640         outcome.setActor(SIMPLE_ACTOR);
 641         outcome.setOperation(SIMPLE_OPERATION);
 642         outcome.setMessage(OUTCOME_MSG);
 643         outcome.setResult(OperationResult.SUCCESS);
 644         outcome.setStart(Instant.now());
 645         outcome.setTarget(MY_TARGET);
 646
 647         return outcome;
 648     }
 649
 650     private void checkResp(OperationOutcome outcome, String expectedPayload) {
 651         ControlLoopResponse resp = mgr.makeControlLoopResponse(outcome);
 652         assertNotNull(resp);
 653         assertEquals(REQ_ID, resp.getRequestId());
 654         assertEquals(expectedPayload, resp.getPayload());
 655     }
 656
 657     /**
 658      * Sets the target entity so a step doesn't have to be added to set it.
 659      */
 660     private void setTargetEntity() {
 661         mgr.setProperty(OperationProperties.AAI_TARGET_ENTITY, MY_TARGET);
 662     }
 663
 664
 665     private class MyManager extends UsecasesEventManager {
 666         private static final long serialVersionUID = 1L;
 667
 668         public MyManager(ControlLoopParams params, VirtualControlLoopEvent event, WorkingMemory workMem)
 669                         throws ControlLoopException {
 670
 671             super(params, event, workMem);
 672         }
 673
 674         @Override
 675         protected ExecutorService getBlockingExecutor() {
 676             return executor;
 677         }
 678
 679         @Override
 680         protected void makeLock(String targetEntity, String requestId, int holdSec, LockCallback callback) {
 681             LockImpl lock = new LockImpl(LockState.ACTIVE, targetEntity, requestId, holdSec, callback);
 682             locks.add(lock);
 683             callback.lockAvailable(lock);
 684         }
 685
 686         @Override
 687         public ActorService getActorService() {
 688             return actors;
 689         }
 690
 691         @Override
 692         public OperationHistoryDataManager getDataManager() {
 693             return dataMgr;
 694         }
 695
 696         @Override
 697         protected PolicyEngine getPolicyEngineManager() {
 698             return engineMgr;
 699         }
 700     }
 701 }