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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * unit test
   4  * ================================================================================
   5  * Copyright (C) 2017-2019 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.eventmanager;
  22
  23 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.junit.Assert.assertNull;
  28 import static org.junit.Assert.assertSame;
  29 import static org.junit.Assert.assertTrue;
  30 import static org.mockito.Matchers.any;
  31 import static org.mockito.Mockito.mock;
  32 import static org.mockito.Mockito.never;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35
  36 import java.io.File;
  37 import java.io.FileInputStream;
  38 import java.io.IOException;
  39 import java.io.InputStream;
  40 import java.io.Serializable;
  41 import java.nio.charset.StandardCharsets;
  42 import java.time.Instant;
  43 import java.util.HashMap;
  44 import java.util.Map;
  45 import java.util.UUID;
  46 import org.apache.commons.io.IOUtils;
  47 import org.junit.AfterClass;
  48 import org.junit.Before;
  49 import org.junit.BeforeClass;
  50 import org.junit.Rule;
  51 import org.junit.Test;
  52 import org.junit.rules.ExpectedException;
  53 import org.onap.policy.common.endpoints.http.server.HttpServletServerFactoryInstance;
  54 import org.onap.policy.common.utils.io.Serializer;
  55 import org.onap.policy.controlloop.ControlLoopEventStatus;
  56 import org.onap.policy.controlloop.ControlLoopException;
  57 import org.onap.policy.controlloop.ControlLoopNotificationType;
  58 import org.onap.policy.controlloop.ControlLoopTargetType;
  59 import org.onap.policy.controlloop.VirtualControlLoopEvent;
  60 import org.onap.policy.controlloop.VirtualControlLoopNotification;
  61 import org.onap.policy.controlloop.eventmanager.ControlLoopEventManager.NewEventStatus;
  62 import org.onap.policy.controlloop.policy.PolicyResult;
  63 import org.onap.policy.drools.core.lock.Lock;
  64 import org.onap.policy.drools.core.lock.LockCallback;
  65 import org.onap.policy.drools.system.PolicyEngineConstants;
  66 import org.onap.policy.drools.utils.Pair;
  67 import org.powermock.reflect.Whitebox;
  68
  69 public class ControlLoopEventManagerTest {
  70     private static final String TARGET_LOCK_FIELD = "targetLock";
  71     private static final String ONSET_ONE = "onsetOne";
  72     private static final String VSERVER_NAME = "vserver.vserver-name";
  73     private static final String TEST_YAML = "src/test/resources/test.yaml";
  74     private static final String VNF_NAME = "generic-vnf.vnf-name";
  75     private static final String VNF_ID = "generic-vnf.vnf-id";
  76     private static final String AAI_USERNAME = "aai.username";
  77     private static final String AAI_URL = "aai.url";
  78     private static final String AAI_PASS = "aai.password";
  79     private static final String TWO_ONSET_TEST = "TwoOnsetTest";
  80     private static final String VNF_UUID = "83f674e8-7555-44d7-9a39-bdc3770b0491";
  81
  82
  83     @Rule
  84     public ExpectedException thrown = ExpectedException.none();
  85
  86     private VirtualControlLoopEvent onset;
  87     private LockCallback callback;
  88
  89     /**
  90      * Set up test class.
  91      */
  92     @BeforeClass
  93     public static void setUpSimulator() throws Exception {
  94         org.onap.policy.simulators.Util.buildAaiSim();
  95
  96         PolicyEngineConstants.getManager().setEnvironmentProperty(AAI_USERNAME, "AAI");
  97         PolicyEngineConstants.getManager().setEnvironmentProperty(AAI_PASS, "AAI");
  98         PolicyEngineConstants.getManager().setEnvironmentProperty(AAI_URL, "http://localhost:6666");
  99         PolicyEngineConstants.getManager().setEnvironmentProperty("aai.customQuery", "false");
 100     }
 101
 102     @AfterClass
 103     public static void tearDownSimulator() {
 104         HttpServletServerFactoryInstance.getServerFactory().destroy();
 105     }
 106
 107     /**
 108      * Setup.
 109      */
 110     @Before
 111     public void setUp() {
 112         callback = mock(LockCallback.class);
 113
 114         onset = new VirtualControlLoopEvent();
 115         onset.setClosedLoopControlName("ControlLoop-vUSP");
 116         onset.setRequestId(UUID.randomUUID());
 117         onset.setTarget("VM_NAME");
 118         onset.setClosedLoopAlarmStart(Instant.now());
 119         onset.setAai(new HashMap<>());
 120         onset.getAai().put("cloud-region.identity-url", "foo");
 121         onset.getAai().put("vserver.selflink", "bar");
 122         onset.getAai().put(VNF_ID, VNF_UUID);
 123         onset.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 124         onset.setTargetType(ControlLoopTargetType.VNF);
 125
 126         PolicyEngineConstants.getManager().setEnvironmentProperty(AAI_URL, "http://localhost:6666");
 127     }
 128
 129     @Test
 130     public void testMethods() {
 131         UUID requestId = UUID.randomUUID();
 132         ControlLoopEventManager clem = new ControlLoopEventManager("MyClosedLoopName", requestId);
 133
 134         assertEquals("MyClosedLoopName", clem.getClosedLoopControlName());
 135         assertEquals(requestId, clem.getRequestId());
 136
 137         clem.setActivated(true);
 138         assertEquals(true, clem.isActivated());
 139
 140         clem.setControlLoopResult("SUCCESS");
 141         assertEquals("SUCCESS", clem.getControlLoopResult());
 142
 143         clem.setControlLoopTimedOut();
 144         assertEquals(true, clem.isControlLoopTimedOut());
 145
 146         clem.setNumAbatements(12345);
 147         assertEquals(Integer.valueOf(12345), clem.getNumAbatements());
 148
 149         clem.setNumOnsets(54321);
 150         assertEquals(Integer.valueOf(54321), clem.getNumOnsets());
 151
 152         assertNull(clem.getOnsetEvent());
 153         assertNull(clem.getAbatementEvent());
 154         assertNull(clem.getProcessor());
 155
 156         assertEquals(true, clem.isControlLoopTimedOut());
 157
 158         assertNull(clem.unlockCurrentOperation());
 159     }
 160
 161     @Test
 162     public void testAlreadyActivated() {
 163         UUID requestId = UUID.randomUUID();
 164         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 165         event.setClosedLoopControlName(TWO_ONSET_TEST);
 166         event.setRequestId(requestId);
 167         event.setTarget(VNF_ID);
 168         event.setClosedLoopAlarmStart(Instant.now());
 169         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 170         event.setAai(new HashMap<>());
 171         event.getAai().put(VNF_NAME, ONSET_ONE);
 172         event.setTargetType(ControlLoopTargetType.VNF);
 173
 174         ControlLoopEventManager manager = makeManager(event);
 175         manager.setActivated(true);
 176         VirtualControlLoopNotification notification = manager.activate(event);
 177         assertEquals(ControlLoopNotificationType.REJECTED, notification.getNotification());
 178     }
 179
 180     @Test
 181     public void testActivationYaml() throws IOException {
 182
 183         UUID requestId = UUID.randomUUID();
 184         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 185         event.setClosedLoopControlName(TWO_ONSET_TEST);
 186         event.setRequestId(requestId);
 187         event.setTarget(VNF_ID);
 188         event.setClosedLoopAlarmStart(Instant.now());
 189         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 190         event.setAai(new HashMap<>());
 191         event.getAai().put(VNF_NAME, ONSET_ONE);
 192         event.setTargetType(ControlLoopTargetType.VNF);
 193
 194         ControlLoopEventManager manager = makeManager(event);
 195
 196         // Null YAML should fail
 197         VirtualControlLoopNotification notificationNull = manager.activate(null, event);
 198         assertNotNull(notificationNull);
 199         assertEquals(ControlLoopNotificationType.REJECTED, notificationNull.getNotification());
 200
 201         // Empty YAML should fail
 202         VirtualControlLoopNotification notificationEmpty = manager.activate("", event);
 203         assertNotNull(notificationEmpty);
 204         assertEquals(ControlLoopNotificationType.REJECTED, notificationEmpty.getNotification());
 205
 206         // Bad YAML should fail
 207         InputStream isBad = new FileInputStream(new File("src/test/resources/notutf8.yaml"));
 208         final String yamlStringBad = IOUtils.toString(isBad, StandardCharsets.UTF_8);
 209
 210         VirtualControlLoopNotification notificationBad = manager.activate(yamlStringBad, event);
 211         assertNotNull(notificationBad);
 212         assertEquals(ControlLoopNotificationType.REJECTED, notificationBad.getNotification());
 213
 214
 215         InputStream is = new FileInputStream(new File(TEST_YAML));
 216         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 217
 218         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 219         assertNotNull(notification);
 220         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 221
 222         // Another activate should fail
 223         VirtualControlLoopNotification notificationActive = manager.activate(yamlString, event);
 224         assertNotNull(notificationActive);
 225         assertEquals(ControlLoopNotificationType.REJECTED, notificationActive.getNotification());
 226     }
 227
 228     @Test
 229     public void testControlLoopFinal() throws Exception {
 230         UUID requestId = UUID.randomUUID();
 231         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 232         event.setClosedLoopControlName(TWO_ONSET_TEST);
 233         event.setRequestId(requestId);
 234         event.setTarget(VNF_ID);
 235         event.setClosedLoopAlarmStart(Instant.now());
 236         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 237         event.setAai(new HashMap<>());
 238         event.getAai().put(VNF_NAME, ONSET_ONE);
 239         event.setTargetType(ControlLoopTargetType.VNF);
 240
 241         ControlLoopEventManager manager = makeManager(event);
 242         ControlLoopEventManager manager2 = manager;
 243         assertThatThrownBy(manager2::isControlLoopFinal).isInstanceOf(ControlLoopException.class)
 244                         .hasMessage("ControlLoopEventManager MUST be activated first.");
 245
 246         manager.setActivated(true);
 247         assertThatThrownBy(manager2::isControlLoopFinal).isInstanceOf(ControlLoopException.class)
 248                         .hasMessage("No onset event for ControlLoopEventManager.");
 249
 250         manager.setActivated(false);
 251
 252         InputStream is = new FileInputStream(new File(TEST_YAML));
 253         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 254
 255         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 256         assertNotNull(notification);
 257         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 258
 259         VirtualControlLoopNotification clfNotification = manager.isControlLoopFinal();
 260         assertNull(clfNotification);
 261
 262         // serialize and de-serialize manager
 263         manager = Serializer.roundTrip(manager);
 264
 265         manager.getProcessor().nextPolicyForResult(PolicyResult.SUCCESS);
 266         clfNotification = manager.isControlLoopFinal();
 267         assertNotNull(clfNotification);
 268         assertEquals(ControlLoopNotificationType.FINAL_SUCCESS, clfNotification.getNotification());
 269
 270         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 271         notification = manager.activate(yamlString, event);
 272         assertNotNull(notification);
 273         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 274
 275         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE_EXCEPTION);
 276         clfNotification = manager.isControlLoopFinal();
 277         assertNotNull(clfNotification);
 278         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 279
 280         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 281         notification = manager.activate(yamlString, event);
 282         assertNotNull(notification);
 283         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 284
 285         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE_GUARD);
 286         clfNotification = manager.isControlLoopFinal();
 287         assertNotNull(clfNotification);
 288         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 289
 290         manager.setControlLoopTimedOut();
 291         clfNotification = manager.isControlLoopFinal();
 292         assertNotNull(clfNotification);
 293         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 294     }
 295
 296     @Test
 297     public void testProcessControlLoop() throws Exception {
 298         UUID requestId = UUID.randomUUID();
 299         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 300         event.setClosedLoopControlName(TWO_ONSET_TEST);
 301         event.setRequestId(requestId);
 302         event.setTarget(VNF_ID);
 303         event.setClosedLoopAlarmStart(Instant.now());
 304         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 305         event.setAai(new HashMap<>());
 306         event.getAai().put(VNF_NAME, ONSET_ONE);
 307         event.getAai().put(VSERVER_NAME, "testVserverName");
 308         event.setTargetType(ControlLoopTargetType.VNF);
 309
 310         ControlLoopEventManager manager = makeManager(event);
 311         ControlLoopEventManager manager2 = manager;
 312         assertThatThrownBy(manager2::processControlLoop).isInstanceOf(ControlLoopException.class)
 313                         .hasMessage("ControlLoopEventManager MUST be activated first.");
 314
 315         manager.setActivated(true);
 316         assertThatThrownBy(manager2::processControlLoop).isInstanceOf(ControlLoopException.class)
 317                         .hasMessage("No onset event for ControlLoopEventManager.");
 318
 319         manager.setActivated(false);
 320
 321         InputStream is = new FileInputStream(new File(TEST_YAML));
 322         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 323
 324         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 325         assertNotNull(notification);
 326         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 327
 328         ControlLoopOperationManager clom = manager.processControlLoop();
 329         assertNotNull(clom);
 330         assertNull(clom.getOperationResult());
 331
 332         // serialize and de-serialize manager
 333         manager = Serializer.roundTrip(manager);
 334
 335         // Test operation in progress
 336         ControlLoopEventManager manager3 = manager;
 337         assertThatThrownBy(manager3::processControlLoop).isInstanceOf(ControlLoopException.class)
 338                         .hasMessage("Already working an Operation, do not call this method.");
 339
 340         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 341         notification = manager.activate(yamlString, event);
 342         assertNotNull(notification);
 343         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 344
 345         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE_GUARD);
 346         VirtualControlLoopNotification clfNotification = manager.isControlLoopFinal();
 347         assertNotNull(clfNotification);
 348         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 349
 350         // Test operation completed
 351         ControlLoopEventManager manager4 = manager;
 352         assertThatThrownBy(manager4::processControlLoop).isInstanceOf(ControlLoopException.class)
 353                         .hasMessage("Control Loop is in FINAL state, do not call this method.");
 354
 355         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 356         notification = manager.activate(yamlString, event);
 357         assertNotNull(notification);
 358         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 359         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE);
 360
 361         // Test operation with no next policy defined
 362         ControlLoopEventManager manager5 = manager;
 363         assertThatThrownBy(manager5::processControlLoop).isInstanceOf(ControlLoopException.class)
 364                         .hasMessage("The target type is null");
 365     }
 366
 367     @Test
 368     public void testFinishOperation() throws Exception {
 369         InputStream isStd = new FileInputStream(new File(TEST_YAML));
 370         final String yamlStringStd = IOUtils.toString(isStd, StandardCharsets.UTF_8);
 371
 372         VirtualControlLoopEvent event = makeEvent();
 373
 374         ControlLoopEventManager manager = makeManager(event);
 375         ControlLoopEventManager manager2 = manager;
 376         assertThatThrownBy(() -> manager2.finishOperation(null)).isInstanceOf(ControlLoopException.class)
 377                         .hasMessage("No operation to finish.");
 378
 379         manager.setActivated(true);
 380         assertThatThrownBy(() -> manager2.finishOperation(null)).isInstanceOf(ControlLoopException.class)
 381                         .hasMessage("No operation to finish.");
 382
 383         manager.setActivated(false);
 384
 385         InputStream is = new FileInputStream(new File("src/test/resources/testSOactor.yaml"));
 386         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 387
 388         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 389         assertNotNull(notification);
 390         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 391
 392         event.getAai().put(VSERVER_NAME, "testVserverName");
 393
 394         // serialize and de-serialize manager
 395         manager = Serializer.roundTrip(manager);
 396
 397         ControlLoopOperationManager clom = manager.processControlLoop();
 398         assertNotNull(clom);
 399         assertNull(clom.getOperationResult());
 400
 401         clom.startOperation(event);
 402
 403         // This call should be exception free
 404         manager.finishOperation(clom);
 405
 406         ControlLoopEventManager otherManager = makeManager(event);
 407         VirtualControlLoopNotification otherNotification = otherManager.activate(yamlStringStd, event);
 408         assertNotNull(otherNotification);
 409         assertEquals(ControlLoopNotificationType.ACTIVE, otherNotification.getNotification());
 410
 411         ControlLoopOperationManager otherClom = otherManager.processControlLoop();
 412         assertNotNull(otherClom);
 413         assertNull(otherClom.getOperationResult());
 414
 415         otherManager.finishOperation(clom);
 416     }
 417
 418     @Test
 419     public void testLockCurrentOperation_testUnlockCurrentOperation() throws Exception {
 420         VirtualControlLoopEvent event = makeEvent();
 421
 422         ControlLoopEventManager manager = makeManager(event);
 423
 424         manager.setActivated(false);
 425
 426         InputStream is = new FileInputStream(new File("src/test/resources/testSOactor.yaml"));
 427         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 428
 429         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 430         assertNotNull(notification);
 431         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 432
 433         ControlLoopEventManager manager2 = manager;
 434         assertThatThrownBy(() -> manager2.lockCurrentOperation(callback)).isInstanceOf(ControlLoopException.class)
 435                         .hasMessage("Do not have a current operation.");
 436
 437         assertNull(manager.unlockCurrentOperation());
 438
 439         event.getAai().put(VSERVER_NAME, "testVserverName");
 440
 441         ControlLoopOperationManager clom = manager.processControlLoop();
 442         assertNotNull(clom);
 443         assertNull(clom.getOperationResult());
 444
 445         Pair<Lock, Lock> lockPair = manager.lockCurrentOperation(callback);
 446         assertNull(lockPair.first());
 447         assertNotNull(lockPair.second());
 448
 449         // pseudo lock - session should NOT have been notified of the change
 450         verify(callback, never()).lockAvailable(any());
 451         verify(callback, never()).lockUnavailable(any());
 452
 453         // repeat - should cause an extension
 454         Lock lock = lockPair.second();
 455         lockPair = manager.lockCurrentOperation(callback);
 456
 457         /*
 458          * even with a pseudo lock, the session should have been notified that it was
 459          * extended
 460          */
 461
 462         verify(callback).lockAvailable(lock);
 463
 464         assertSame(lock, manager.unlockCurrentOperation());
 465
 466         assertNull(lockPair.first());
 467         assertNull(lockPair.second());
 468
 469         // force it to use a pseudo lock
 470         manager.setUseTargetLock(false);
 471         lockPair = manager.lockCurrentOperation(callback);
 472         assertNull(lockPair.first());
 473         assertNotNull(lockPair.second());
 474
 475         lock = lockPair.second();
 476
 477         lockPair = manager.lockCurrentOperation(callback);
 478         assertNull(lockPair.first());
 479         assertNull(lockPair.second());
 480
 481         // first lock uses a pseudo lock, so it will only update when extended
 482         verify(callback).lockAvailable(lock);
 483
 484         // force it to re-create the lock due to change in resource ID
 485         lock = mock(Lock.class);
 486         when(lock.getResourceId()).thenReturn("different");
 487         Whitebox.setInternalState(manager, TARGET_LOCK_FIELD, lock);
 488
 489         lockPair = manager.lockCurrentOperation(callback);
 490         assertSame(lock, lockPair.first());
 491         assertNotNull(lockPair.second());
 492
 493         lock = lockPair.second();
 494
 495         lockPair = manager.lockCurrentOperation(callback);
 496         assertNull(lockPair.first());
 497         assertNull(lockPair.second());
 498
 499         // first lock uses a pseudo lock, so it won't do an update
 500         verify(callback).lockAvailable(lock);
 501
 502         assertSame(lock, manager.unlockCurrentOperation());
 503         assertNull(manager.unlockCurrentOperation());
 504
 505         // try again - this time don't return the fact handle- no change in count
 506         lockPair = manager.lockCurrentOperation(callback);
 507         assertNull(lockPair.first());
 508         assertNotNull(lockPair.second());
 509     }
 510
 511     @Test
 512     public void testOnNewEvent() throws Exception {
 513         UUID requestId = UUID.randomUUID();
 514         VirtualControlLoopEvent onsetEvent = new VirtualControlLoopEvent();
 515         onsetEvent.setClosedLoopControlName(TWO_ONSET_TEST);
 516         onsetEvent.setRequestId(requestId);
 517         onsetEvent.setTarget(VNF_ID);
 518         onsetEvent.setClosedLoopAlarmStart(Instant.now());
 519         onsetEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 520         onsetEvent.setAai(new HashMap<>());
 521         onsetEvent.getAai().put(VNF_NAME, ONSET_ONE);
 522         onsetEvent.setTargetType(ControlLoopTargetType.VNF);
 523
 524         VirtualControlLoopEvent abatedEvent = new VirtualControlLoopEvent();
 525         abatedEvent.setClosedLoopControlName(TWO_ONSET_TEST);
 526         abatedEvent.setRequestId(requestId);
 527         abatedEvent.setTarget(VNF_ID);
 528         abatedEvent.setClosedLoopAlarmStart(Instant.now());
 529         abatedEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ABATED);
 530         abatedEvent.setAai(new HashMap<>());
 531         abatedEvent.getAai().put(VNF_NAME, ONSET_ONE);
 532
 533         ControlLoopEventManager manager = makeManager(onsetEvent);
 534
 535         InputStream is = new FileInputStream(new File(TEST_YAML));
 536         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 537
 538         VirtualControlLoopNotification notification = manager.activate(yamlString, onsetEvent);
 539         assertNotNull(notification);
 540         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 541
 542         assertEquals(NewEventStatus.FIRST_ONSET, manager.onNewEvent(onsetEvent));
 543         assertEquals(NewEventStatus.FIRST_ABATEMENT, manager.onNewEvent(abatedEvent));
 544         assertEquals(NewEventStatus.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 545
 546         VirtualControlLoopEvent checkSyntaxEvent = new VirtualControlLoopEvent();
 547         checkSyntaxEvent.setAai(null);
 548         checkSyntaxEvent.setClosedLoopAlarmEnd(null);
 549         checkSyntaxEvent.setClosedLoopAlarmStart(null);
 550         checkSyntaxEvent.setClosedLoopControlName(null);
 551         checkSyntaxEvent.setClosedLoopEventClient(null);
 552         checkSyntaxEvent.setClosedLoopEventStatus(null);
 553         checkSyntaxEvent.setFrom(null);
 554         checkSyntaxEvent.setPolicyName(null);
 555         checkSyntaxEvent.setPolicyScope(null);
 556         checkSyntaxEvent.setPolicyVersion(null);
 557         checkSyntaxEvent.setRequestId(null);
 558         checkSyntaxEvent.setTarget(null);
 559         checkSyntaxEvent.setTargetType(null);
 560         checkSyntaxEvent.setVersion(null);
 561
 562         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 563
 564         checkSyntaxEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 565         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 566
 567         checkSyntaxEvent.setClosedLoopControlName(null);
 568         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 569
 570         checkSyntaxEvent.setClosedLoopControlName("");
 571         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 572
 573         checkSyntaxEvent.setClosedLoopControlName(TWO_ONSET_TEST);
 574         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 575
 576         checkSyntaxEvent.setRequestId(null);
 577         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 578
 579         checkSyntaxEvent.setRequestId(requestId);
 580         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 581
 582         checkSyntaxEvent.setAai(null);
 583         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 584
 585         checkSyntaxEvent.setAai(new HashMap<>());
 586         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 587
 588         checkSyntaxEvent.setTargetType("");
 589         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 590
 591         checkSyntaxEvent.setTarget("");
 592         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 593
 594         checkSyntaxEvent.setTarget(null);
 595         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 596
 597         checkSyntaxEvent.setTarget("");
 598         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 599
 600         checkSyntaxEvent.setTarget("OZ");
 601         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 602
 603         checkSyntaxEvent.setTarget("VM_NAME");
 604         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 605
 606         checkSyntaxEvent.setTarget("VNF_NAME");
 607         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 608
 609         checkSyntaxEvent.setTarget(VSERVER_NAME);
 610         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 611
 612         checkSyntaxEvent.setTarget(VNF_ID);
 613         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 614
 615         checkSyntaxEvent.setTarget(VNF_NAME);
 616         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 617
 618         checkSyntaxEvent.setAai(null);
 619         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 620
 621         checkSyntaxEvent.setAai(new HashMap<>());
 622         assertEquals(NewEventStatus.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 623
 624         checkSyntaxEvent.getAai().put(VNF_NAME, ONSET_ONE);
 625         assertEquals(NewEventStatus.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 626
 627         checkSyntaxEvent.getAai().put(VSERVER_NAME, ONSET_ONE);
 628         assertEquals(NewEventStatus.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 629
 630         checkSyntaxEvent.getAai().put(VNF_ID, ONSET_ONE);
 631         assertEquals(NewEventStatus.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 632     }
 633
 634     @Test
 635     public void testControlLoopTimeout() throws IOException {
 636         UUID requestId = UUID.randomUUID();
 637         VirtualControlLoopEvent onsetEvent = new VirtualControlLoopEvent();
 638         onsetEvent.setClosedLoopControlName(TWO_ONSET_TEST);
 639         onsetEvent.setRequestId(requestId);
 640         onsetEvent.setTarget(VNF_ID);
 641         onsetEvent.setClosedLoopAlarmStart(Instant.now());
 642         onsetEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 643         onsetEvent.setAai(new HashMap<>());
 644         onsetEvent.getAai().put(VNF_NAME, ONSET_ONE);
 645         onsetEvent.setTargetType(ControlLoopTargetType.VNF);
 646
 647         ControlLoopEventManager manager = makeManager(onsetEvent);
 648         assertTrue(0 == manager.getControlLoopTimeout(null));
 649         assertTrue(120 == manager.getControlLoopTimeout(120));
 650
 651         InputStream is = new FileInputStream(new File(TEST_YAML));
 652         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 653
 654         VirtualControlLoopNotification notification = manager.activate(yamlString, onsetEvent);
 655         assertNotNull(notification);
 656         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 657
 658         assertEquals(60, manager.getControlLoopTimeout(null));
 659     }
 660
 661     @Test
 662     public void testControlLoopTimeout_ZeroTimeout() throws IOException {
 663         UUID requestId = UUID.randomUUID();
 664         VirtualControlLoopEvent onsetEvent = new VirtualControlLoopEvent();
 665         onsetEvent.setClosedLoopControlName(TWO_ONSET_TEST);
 666         onsetEvent.setRequestId(requestId);
 667         onsetEvent.setTarget(VNF_ID);
 668         onsetEvent.setClosedLoopAlarmStart(Instant.now());
 669         onsetEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 670         onsetEvent.setAai(new HashMap<>());
 671         onsetEvent.getAai().put(VNF_NAME, ONSET_ONE);
 672         onsetEvent.setTargetType(ControlLoopTargetType.VNF);
 673
 674         ControlLoopEventManager manager = makeManager(onsetEvent);
 675
 676         InputStream is = new FileInputStream(new File("src/test/resources/test-zero-timeout.yaml"));
 677         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 678
 679         VirtualControlLoopNotification notification = manager.activate(yamlString, onsetEvent);
 680         assertNotNull(notification);
 681         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 682
 683         assertTrue(0 == manager.getControlLoopTimeout(null));
 684         assertTrue(120 == manager.getControlLoopTimeout(120));
 685     }
 686
 687     @Test
 688     public void testControlLoopTimeout_NullTimeout() throws IOException {
 689         UUID requestId = UUID.randomUUID();
 690         VirtualControlLoopEvent onsetEvent = new VirtualControlLoopEvent();
 691         onsetEvent.setClosedLoopControlName(TWO_ONSET_TEST);
 692         onsetEvent.setRequestId(requestId);
 693         onsetEvent.setTarget(VNF_ID);
 694         onsetEvent.setClosedLoopAlarmStart(Instant.now());
 695         onsetEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 696         onsetEvent.setAai(new HashMap<>());
 697         onsetEvent.getAai().put(VNF_NAME, ONSET_ONE);
 698         onsetEvent.setTargetType(ControlLoopTargetType.VNF);
 699
 700         ControlLoopEventManager manager = makeManager(onsetEvent);
 701
 702         InputStream is = new FileInputStream(new File("src/test/resources/test-null-timeout.yaml"));
 703         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 704
 705         VirtualControlLoopNotification notification = manager.activate(yamlString, onsetEvent);
 706         assertNotNull(notification);
 707         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 708
 709         assertTrue(0 == manager.getControlLoopTimeout(null));
 710         assertTrue(120 == manager.getControlLoopTimeout(120));
 711     }
 712
 713     @Test
 714     public void testIsClosedLoopDisabled() {
 715         Map<String, String> aai = onset.getAai();
 716
 717         // null, null
 718         aai.remove(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED);
 719         aai.remove(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED);
 720         assertFalse(ControlLoopEventManager.isClosedLoopDisabled(onset));
 721
 722         // null, false
 723         aai.remove(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED);
 724         aai.put(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED, Boolean.FALSE.toString());
 725         assertFalse(ControlLoopEventManager.isClosedLoopDisabled(onset));
 726
 727         // false, null
 728         aai.put(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED, Boolean.FALSE.toString());
 729         aai.remove(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED);
 730         assertFalse(ControlLoopEventManager.isClosedLoopDisabled(onset));
 731
 732         // null, true
 733         aai.remove(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED);
 734         aai.put(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED, Boolean.TRUE.toString());
 735         assertTrue(ControlLoopEventManager.isClosedLoopDisabled(onset));
 736
 737         // true, null
 738         aai.put(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED, Boolean.TRUE.toString());
 739         aai.remove(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED);
 740         assertTrue(ControlLoopEventManager.isClosedLoopDisabled(onset));
 741     }
 742
 743     @Test
 744     public void testIsProvStatusInactive() {
 745         Map<String, String> aai = onset.getAai();
 746
 747         // null, null
 748         aai.remove(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS);
 749         aai.remove(ControlLoopEventManager.VSERVER_PROV_STATUS);
 750         assertFalse(ControlLoopEventManager.isProvStatusInactive(onset));
 751
 752         // null, active
 753         aai.remove(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS);
 754         aai.put(ControlLoopEventManager.VSERVER_PROV_STATUS, ControlLoopEventManager.PROV_STATUS_ACTIVE);
 755         assertFalse(ControlLoopEventManager.isProvStatusInactive(onset));
 756
 757         // active, null
 758         aai.put(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS, ControlLoopEventManager.PROV_STATUS_ACTIVE);
 759         aai.remove(ControlLoopEventManager.VSERVER_PROV_STATUS);
 760         assertFalse(ControlLoopEventManager.isProvStatusInactive(onset));
 761
 762         // null, inactive
 763         aai.remove(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS);
 764         aai.put(ControlLoopEventManager.VSERVER_PROV_STATUS, "other1");
 765         assertTrue(ControlLoopEventManager.isProvStatusInactive(onset));
 766
 767         // inactive, null
 768         aai.put(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS, "other2");
 769         aai.remove(ControlLoopEventManager.VSERVER_PROV_STATUS);
 770         assertTrue(ControlLoopEventManager.isProvStatusInactive(onset));
 771     }
 772
 773     @Test
 774     public void testIsAaiTrue() {
 775         assertTrue(ControlLoopEventManager.isAaiTrue("tRuE"));
 776         assertTrue(ControlLoopEventManager.isAaiTrue("T"));
 777         assertTrue(ControlLoopEventManager.isAaiTrue("t"));
 778         assertTrue(ControlLoopEventManager.isAaiTrue("yES"));
 779         assertTrue(ControlLoopEventManager.isAaiTrue("Y"));
 780         assertTrue(ControlLoopEventManager.isAaiTrue("y"));
 781
 782         assertFalse(ControlLoopEventManager.isAaiTrue("no"));
 783         assertFalse(ControlLoopEventManager.isAaiTrue(null));
 784     }
 785
 786
 787     private VirtualControlLoopEvent makeEvent() {
 788         UUID requestId = UUID.randomUUID();
 789         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 790         event.setClosedLoopControlName(TWO_ONSET_TEST);
 791         event.setRequestId(requestId);
 792         event.setTarget(VNF_ID);
 793         event.setClosedLoopAlarmStart(Instant.now());
 794         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 795         event.setAai(new HashMap<>());
 796         event.getAai().put(VNF_ID, ONSET_ONE);
 797         event.getAai().put(VSERVER_NAME, "test-vserver");
 798         event.setTargetType(ControlLoopTargetType.VNF);
 799         return event;
 800     }
 801
 802     private ControlLoopEventManager makeManager(VirtualControlLoopEvent event) {
 803         return new MyManager(event.getClosedLoopControlName(), event.getRequestId());
 804     }
 805
 806     private static class MyManager extends ControlLoopEventManager implements Serializable {
 807         private static final long serialVersionUID = 1L;
 808
 809         public MyManager(String closedLoopControlName, UUID requestId) {
 810             super(closedLoopControlName, requestId);
 811         }
 812
 813         @Override
 814         protected Lock createRealLock(String targetEntity, UUID requestId, int holdSec, LockCallback callback) {
 815             return createPseudoLock(targetEntity, requestId, holdSec, callback);
 816         }
 817     }
 818 }