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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * unit test
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 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.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertNull;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.junit.Assert.fail;
  29 import java.io.File;
  30 import java.io.FileInputStream;
  31 import java.io.IOException;
  32 import java.io.InputStream;
  33 import java.nio.charset.StandardCharsets;
  34 import java.time.Instant;
  35 import java.util.HashMap;
  36 import java.util.Map;
  37 import java.util.UUID;
  38 import org.apache.commons.io.IOUtils;
  39 import org.junit.AfterClass;
  40 import org.junit.Before;
  41 import org.junit.BeforeClass;
  42 import org.junit.Rule;
  43 import org.junit.Test;
  44 import org.junit.rules.ExpectedException;
  45 import org.onap.policy.aai.AaiGetVnfResponse;
  46 import org.onap.policy.aai.AaiGetVserverResponse;
  47 import org.onap.policy.aai.AaiNqVServer;
  48 import org.onap.policy.aai.AaiNqRequestError;
  49 import org.onap.policy.aai.RelatedToProperty;
  50 import org.onap.policy.aai.Relationship;
  51 import org.onap.policy.aai.RelationshipData;
  52 import org.onap.policy.aai.RelationshipList;
  53 import org.onap.policy.aai.util.AaiException;
  54 import org.onap.policy.common.endpoints.http.server.HttpServletServer;
  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.Util;
  59 import org.onap.policy.controlloop.VirtualControlLoopEvent;
  60 import org.onap.policy.controlloop.VirtualControlLoopNotification;
  61 import org.onap.policy.controlloop.eventmanager.ControlLoopEventManager.NEW_EVENT_STATUS;
  62 import org.onap.policy.controlloop.policy.ControlLoopPolicy;
  63 import org.onap.policy.controlloop.policy.PolicyResult;
  64 import org.onap.policy.drools.system.PolicyEngine;
  65 import org.onap.policy.guard.GuardResult;
  66 import org.onap.policy.guard.PolicyGuard;
  67 import org.onap.policy.guard.PolicyGuard.LockResult;
  68 import org.onap.policy.guard.TargetLock;
  69 import org.powermock.reflect.Whitebox;
  70 import org.slf4j.Logger;
  71 import org.slf4j.LoggerFactory;
  72
  73 public class ControlLoopEventManagerTest {
  74     private static final Logger logger = LoggerFactory.getLogger(ControlLoopEventManagerTest.class);
  75
  76     @Rule
  77     public ExpectedException thrown = ExpectedException.none();
  78
  79     private VirtualControlLoopEvent onset;
  80
  81     /**
  82      * Set up test class.
  83      */
  84     @BeforeClass
  85     public static void setUpSimulator() {
  86         try {
  87             org.onap.policy.simulators.Util.buildAaiSim();
  88         } catch (Exception e) {
  89             fail(e.getMessage());
  90         }
  91         PolicyEngine.manager.setEnvironmentProperty("aai.username", "AAI");
  92         PolicyEngine.manager.setEnvironmentProperty("aai.password", "AAI");
  93         PolicyEngine.manager.setEnvironmentProperty("aai.url", "http://localhost:6666");
  94     }
  95
  96     @AfterClass
  97     public static void tearDownSimulator() {
  98         HttpServletServer.factory.destroy();
  99     }
 100
 101     @Before
 102     public void setUp() {
 103         onset = new VirtualControlLoopEvent();
 104         onset.setClosedLoopControlName("ControlLoop-vUSP");
 105         onset.setRequestId(UUID.randomUUID());
 106         onset.setTarget("VM_NAME");
 107         onset.setClosedLoopAlarmStart(Instant.now());
 108         onset.setAai(new HashMap<String, String>());
 109         onset.getAai().put("cloud-region.identity-url", "foo");
 110         onset.getAai().put("vserver.selflink", "bar");
 111         onset.getAai().put("generic-vnf.vnf-id", "83f674e8-7555-44d7-9a39-bdc3770b0491");
 112         onset.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 113
 114         PolicyEngine.manager.setEnvironmentProperty("aai.url", "http://localhost:6666");
 115     }
 116
 117     @Test
 118     public void testAaiVnfInfo() {
 119         final Util.Pair<ControlLoopPolicy, String> pair = Util.loadYaml("src/test/resources/test.yaml");
 120         onset.setClosedLoopControlName(pair.key.getControlLoop().getControlLoopName());
 121         try {
 122             AaiGetVnfResponse response = getQueryByVnfId2(
 123                     PolicyEngine.manager.getEnvironmentProperty("aai.url")
 124                             + "/aai/v11/network/generic-vnfs/generic-vnf/",
 125                     PolicyEngine.manager.getEnvironmentProperty("aai.username"),
 126                     PolicyEngine.manager.getEnvironmentProperty("aai.password"), UUID.randomUUID(),
 127                     "5e49ca06-2972-4532-9ed4-6d071588d792");
 128             assertNotNull(response);
 129             logger.info("testAAIVnfInfo test result is " + (response == null ? "null" : "not null"));
 130         } catch (Exception e) {
 131             logger.error("testAAIVnfInfo Exception: ", e);
 132             fail(e.getMessage());
 133         }
 134     }
 135
 136     @Test
 137     public void testAaiVnfInfo2() {
 138         final Util.Pair<ControlLoopPolicy, String> pair = Util.loadYaml("src/test/resources/test.yaml");
 139         onset.setClosedLoopControlName(pair.key.getControlLoop().getControlLoopName());
 140         try {
 141             AaiGetVnfResponse response = getQueryByVnfName2(
 142                     PolicyEngine.manager.getEnvironmentProperty("aai.url")
 143                             + "/aai/v11/network/generic-vnfs/generic-vnf?vnf-name=",
 144                     PolicyEngine.manager.getEnvironmentProperty("aai.username"),
 145                     PolicyEngine.manager.getEnvironmentProperty("aai.password"), UUID.randomUUID(), "lll_vnf_010317");
 146             assertNotNull(response);
 147             logger.info("testAAIVnfInfo2 test result is " + (response == null ? "null" : "not null"));
 148         } catch (Exception e) {
 149             logger.error("testAAIVnfInfo2 Exception: ", e);
 150             fail(e.getMessage());
 151         }
 152     }
 153
 154     @Test
 155     public void testAaiVserver() {
 156         final Util.Pair<ControlLoopPolicy, String> pair = Util.loadYaml("src/test/resources/test.yaml");
 157         onset.setClosedLoopControlName(pair.key.getControlLoop().getControlLoopName());
 158         try {
 159             AaiGetVserverResponse response = getQueryByVserverName2(
 160                     PolicyEngine.manager.getEnvironmentProperty("aai.url") + "/aai/v11/nodes/vservers?vserver-name=",
 161                     PolicyEngine.manager.getEnvironmentProperty("aai.username"),
 162                     PolicyEngine.manager.getEnvironmentProperty("aai.password"), UUID.randomUUID(),
 163                     "USMSO1SX7NJ0103UJZZ01-vjunos0");
 164             assertNotNull(response);
 165             logger.info("testAAIVserver test result is " + (response == null ? "null" : "not null"));
 166         } catch (Exception e) {
 167             logger.error("testAAIVserver Exception: ", e);
 168             fail(e.getMessage());
 169         }
 170     }
 171
 172     @Test
 173     public void abatementCheckEventSyntaxTest() {
 174         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 175         event.setClosedLoopControlName("abatementAAI");
 176         event.setRequestId(UUID.randomUUID());
 177         event.setTarget("generic-vnf.vnf-id");
 178         event.setClosedLoopAlarmStart(Instant.now());
 179         event.setClosedLoopEventStatus(ControlLoopEventStatus.ABATED);
 180         ControlLoopEventManager manager = makeManager(event);
 181         assertNull(manager.getVnfResponse());
 182         assertNull(manager.getVserverResponse());
 183         try {
 184             manager.checkEventSyntax(event);
 185         } catch (ControlLoopException e) {
 186             logger.debug("ControlLoopException in abatemetCheckEventSyntaxTest: " + e.getMessage());
 187             e.printStackTrace();
 188             fail("Exception in check event syntax");
 189         }
 190         assertNull(manager.getVnfResponse());
 191         assertNull(manager.getVserverResponse());
 192
 193
 194         event.setAai(new HashMap<>());
 195         event.getAai().put("generic-vnf.vnf-name", "abatementTest");
 196         try {
 197             manager.checkEventSyntax(event);
 198         } catch (ControlLoopException e) {
 199             logger.debug("ControlLoopException in abatemetCheckEventSyntaxTest: " + e.getMessage());
 200             e.printStackTrace();
 201             fail("Exception in check event syntax");
 202         }
 203         assertNull(manager.getVnfResponse());
 204         assertNull(manager.getVserverResponse());
 205     }
 206
 207     @Test
 208     public void subsequentOnsetTest() {
 209         UUID requestId = UUID.randomUUID();
 210         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 211         event.setClosedLoopControlName("TwoOnsetTest");
 212         event.setRequestId(requestId);
 213         event.setTarget("generic-vnf.vnf-id");
 214         event.setClosedLoopAlarmStart(Instant.now());
 215         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 216         event.setAai(new HashMap<>());
 217         event.getAai().put("generic-vnf.vnf-name", "onsetOne");
 218
 219         ControlLoopEventManager manager = makeManager(event);
 220         VirtualControlLoopNotification notification = manager.activate(event);
 221
 222         assertNotNull(notification);
 223         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 224
 225         ControlLoopEventManager.NEW_EVENT_STATUS status = null;
 226         try {
 227             status = manager.onNewEvent(event);
 228         } catch (AaiException e) {
 229             logger.warn(e.toString());
 230             fail("A&AI Query Failed");
 231         }
 232         assertNotNull(status);
 233         assertEquals(ControlLoopEventManager.NEW_EVENT_STATUS.FIRST_ONSET, status);
 234
 235         AaiGetVnfResponse response = manager.getVnfResponse();
 236         assertNotNull(response);
 237         assertNull(manager.getVserverResponse());
 238
 239         VirtualControlLoopEvent event2 = new VirtualControlLoopEvent();
 240         event2.setClosedLoopControlName("TwoOnsetTest");
 241         event2.setRequestId(requestId);
 242         event2.setTarget("generic-vnf.vnf-id");
 243         event2.setClosedLoopAlarmStart(Instant.now());
 244         event2.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 245         event2.setAai(new HashMap<>());
 246         event2.getAai().put("generic-vnf.vnf-name", "onsetTwo");
 247
 248
 249         try {
 250             status = manager.onNewEvent(event2);
 251         } catch (AaiException e) {
 252             logger.warn(e.toString());
 253             fail("A&AI Query Failed");
 254         }
 255         assertEquals(ControlLoopEventManager.NEW_EVENT_STATUS.SUBSEQUENT_ONSET, status);
 256         AaiGetVnfResponse response2 = manager.getVnfResponse();
 257         assertNotNull(response2);
 258         // We should not have queried AAI, so the stored response should be the same
 259         assertEquals(response, response2);
 260         assertNull(manager.getVserverResponse());
 261     }
 262
 263     /**
 264      * Simulate a response.
 265      */
 266     public static AaiGetVnfResponse getQueryByVnfId2(String urlGet, String username, String password, UUID requestId,
 267             String key) {
 268         AaiGetVnfResponse response = new AaiGetVnfResponse();
 269
 270         response.setVnfId("83f674e8-7555-44d7-9a39-bdc3770b0491");
 271         response.setVnfName("lll_vnf_010317");
 272         response.setVnfType("Basa-122216-Service/VidVsamp12BaseVolume 1");
 273         response.setServiceId("a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb");
 274         response.setOrchestrationStatus("Created");
 275         response.setInMaint(false);
 276         response.setIsClosedLoopDisabled(false);
 277         response.setResourceVersion("1494001988835");
 278         response.setModelInvariantId("f18be3cd-d446-456e-9109-121d9b62feaa");
 279
 280         final RelationshipList relationshipList = new RelationshipList();
 281         final Relationship relationship = new Relationship();
 282         RelationshipData relationshipDataItem = new RelationshipData();
 283
 284         relationshipDataItem.setRelationshipKey("customer.global-customer-id");
 285         relationshipDataItem.setRelationshipValue("MSO_1610_ST");
 286         relationship.getRelationshipData().add(relationshipDataItem);
 287
 288         relationshipDataItem.setRelationshipKey("service-subscription.service-type");
 289         relationshipDataItem.setRelationshipValue("MSO-dev-service-type");
 290         relationship.getRelationshipData().add(relationshipDataItem);
 291
 292         relationshipDataItem.setRelationshipKey("service-instance.service-instance-id");
 293         relationshipDataItem.setRelationshipValue("e1e9c97c-02c0-4919-9b4c-eb5d5ef68970");
 294         relationship.getRelationshipData().add(relationshipDataItem);
 295
 296         RelatedToProperty item = new RelatedToProperty();
 297         item.setPropertyKey("service-instance.service-instance-name");
 298         item.setPropertyValue("lll_svc_010317");
 299         relationship.getRelatedToProperty().add(item);
 300
 301         relationship.setRelatedTo("service-instance");
 302         relationship.setRelatedLink(
 303                 "/aai/v11/business/customers/customer/MSO_1610_ST/service-subscriptions/service-subscription"
 304                         + "/MSO-dev-service-type/service-instances/service-instance/"
 305                         + "e1e9c97c-02c0-4919-9b4c-eb5d5ef68970");
 306
 307         relationshipList.getRelationships().add(relationship);
 308         response.setRelationshipList(relationshipList);
 309
 310         return response;
 311     }
 312
 313     /**
 314      * Simulate a response.
 315      */
 316     public static AaiGetVnfResponse getQueryByVnfName2(String urlGet, String username, String password, UUID requestId,
 317             String key) {
 318         AaiGetVnfResponse response = new AaiGetVnfResponse();
 319
 320         response.setVnfId("83f674e8-7555-44d7-9a39-bdc3770b0491");
 321         response.setVnfName("lll_vnf_010317");
 322         response.setVnfType("Basa-122216-Service/VidVsamp12BaseVolume 1");
 323         response.setServiceId("a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb");
 324         response.setOrchestrationStatus("Created");
 325         response.setInMaint(false);
 326         response.setIsClosedLoopDisabled(false);
 327         response.setResourceVersion("1494001988835");
 328         response.setModelInvariantId("f18be3cd-d446-456e-9109-121d9b62feaa");
 329
 330         final RelationshipList relationshipList = new RelationshipList();
 331         final Relationship relationship = new Relationship();
 332         RelationshipData relationshipDataItem = new RelationshipData();
 333
 334         relationshipDataItem.setRelationshipKey("customer.global-customer-id");
 335         relationshipDataItem.setRelationshipValue("MSO_1610_ST");
 336         relationship.getRelationshipData().add(relationshipDataItem);
 337
 338         relationshipDataItem.setRelationshipKey("service-subscription.service-type");
 339         relationshipDataItem.setRelationshipValue("MSO-dev-service-type");
 340         relationship.getRelationshipData().add(relationshipDataItem);
 341
 342         relationshipDataItem.setRelationshipKey("service-instance.service-instance-id");
 343         relationshipDataItem.setRelationshipValue("e1e9c97c-02c0-4919-9b4c-eb5d5ef68970");
 344         relationship.getRelationshipData().add(relationshipDataItem);
 345
 346         RelatedToProperty item = new RelatedToProperty();
 347         item.setPropertyKey("service-instance.service-instance-name");
 348         item.setPropertyValue("lll_svc_010317");
 349         relationship.getRelatedToProperty().add(item);
 350
 351         relationship.setRelatedTo("service-instance");
 352         relationship.setRelatedLink(
 353                 "/aai/v11/business/customers/customer/MSO_1610_ST/service-subscriptions/service-subscription"
 354                         + "/MSO-dev-service-type/service-instances/service-instance/"
 355                         + "e1e9c97c-02c0-4919-9b4c-eb5d5ef68970");
 356
 357         relationshipList.getRelationships().add(relationship);
 358         response.setRelationshipList(relationshipList);
 359
 360         return response;
 361     }
 362
 363     /**
 364      * Simulate a response.
 365      */
 366     public static AaiGetVserverResponse getQueryByVserverName2(String urlGet, String username, String password,
 367             UUID requestId, String key) {
 368         AaiGetVserverResponse response = new AaiGetVserverResponse();
 369
 370         AaiNqVServer svr = new AaiNqVServer();
 371
 372         svr.setVserverId("d0668d4f-c25e-4a1b-87c4-83845c01efd8");
 373         svr.setVserverName("USMSO1SX7NJ0103UJZZ01-vjunos0");
 374         svr.setVserverName2("vjunos0");
 375         svr.setVserverSelflink(
 376                 "https://aai-ext1.test.att.com:8443/aai/v7/cloud-infrastructure/cloud-regions/cloud-region/att-aic/AAIAIC25/tenants/tenant/USMSO1SX7NJ0103UJZZ01%3A%3AuCPE-VMS/vservers/vserver/d0668d4f-c25e-4a1b-87c4-83845c01efd8");
 377         svr.setInMaint(false);
 378         svr.setIsClosedLoopDisabled(false);
 379         svr.setResourceVersion("1494001931513");
 380
 381         final RelationshipList relationshipList = new RelationshipList();
 382         final Relationship relationship = new Relationship();
 383         RelationshipData relationshipDataItem = new RelationshipData();
 384
 385         relationshipDataItem.setRelationshipKey("customer.global-customer-id");
 386         relationshipDataItem.setRelationshipValue("MSO_1610_ST");
 387         relationship.getRelationshipData().add(relationshipDataItem);
 388
 389         relationshipDataItem.setRelationshipKey("service-subscription.service-type");
 390         relationshipDataItem.setRelationshipValue("MSO-dev-service-type");
 391         relationship.getRelationshipData().add(relationshipDataItem);
 392
 393         relationshipDataItem.setRelationshipKey("service-instance.service-instance-id");
 394         relationshipDataItem.setRelationshipValue("e1e9c97c-02c0-4919-9b4c-eb5d5ef68970");
 395         relationship.getRelationshipData().add(relationshipDataItem);
 396
 397         RelatedToProperty item = new RelatedToProperty();
 398         item.setPropertyKey("service-instance.service-instance-name");
 399         item.setPropertyValue("lll_svc_010317");
 400         relationship.getRelatedToProperty().add(item);
 401
 402         relationship.setRelatedTo("service-instance");
 403         relationship.setRelatedLink(
 404                 "/aai/v11/business/customers/customer/MSO_1610_ST/service-subscriptions/service-subscription"
 405                         + "/MSO-dev-service-type/service-instances/service-instance/"
 406                         + "e1e9c97c-02c0-4919-9b4c-eb5d5ef68970");
 407
 408         relationshipList.getRelationships().add(relationship);
 409         svr.setRelationshipList(relationshipList);
 410
 411         response.getVserver().add(svr);
 412
 413         return response;
 414     }
 415
 416     @Test
 417     public void testMethods() {
 418         UUID requestId = UUID.randomUUID();
 419         ControlLoopEventManager clem = new ControlLoopEventManager("MyClosedLoopName", requestId);
 420
 421         assertEquals("MyClosedLoopName", clem.getClosedLoopControlName());
 422         assertEquals(requestId, clem.getRequestID());
 423
 424         clem.setActivated(true);
 425         assertEquals(true, clem.isActivated());
 426
 427         clem.setControlLoopResult("SUCCESS");
 428         assertEquals("SUCCESS", clem.getControlLoopResult());
 429
 430         clem.setControlLoopTimedOut();
 431         assertEquals(true, clem.isControlLoopTimedOut());
 432
 433         clem.setNumAbatements(12345);
 434         assertEquals(Integer.valueOf(12345), clem.getNumAbatements());
 435
 436         clem.setNumOnsets(54321);
 437         assertEquals(Integer.valueOf(54321), clem.getNumOnsets());
 438
 439         assertNull(clem.getOnsetEvent());
 440         assertNull(clem.getAbatementEvent());
 441         assertNull(clem.getProcessor());
 442
 443         assertEquals(true, clem.isActive());
 444         assertEquals(false, clem.releaseLock());
 445         assertEquals(true, clem.isControlLoopTimedOut());
 446
 447         assertNull(clem.unlockCurrentOperation());
 448     }
 449
 450     @Test
 451     public void testAlreadyActivated() {
 452         UUID requestId = UUID.randomUUID();
 453         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 454         event.setClosedLoopControlName("TwoOnsetTest");
 455         event.setRequestId(requestId);
 456         event.setTarget("generic-vnf.vnf-id");
 457         event.setClosedLoopAlarmStart(Instant.now());
 458         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 459         event.setAai(new HashMap<>());
 460         event.getAai().put("generic-vnf.vnf-name", "onsetOne");
 461
 462         ControlLoopEventManager manager = makeManager(event);
 463         manager.setActivated(true);
 464         VirtualControlLoopNotification notification = manager.activate(event);
 465         assertEquals(ControlLoopNotificationType.REJECTED, notification.getNotification());
 466     }
 467
 468     @Test
 469     public void testActivationYaml() throws IOException {
 470         InputStream is = new FileInputStream(new File("src/test/resources/test.yaml"));
 471         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 472
 473         InputStream isBad = new FileInputStream(new File("src/test/resources/notutf8.yaml"));
 474         final String yamlStringBad = IOUtils.toString(isBad, StandardCharsets.UTF_8);
 475
 476         UUID requestId = UUID.randomUUID();
 477         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 478         event.setClosedLoopControlName("TwoOnsetTest");
 479         event.setRequestId(requestId);
 480         event.setTarget("generic-vnf.vnf-id");
 481         event.setClosedLoopAlarmStart(Instant.now());
 482         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 483         event.setAai(new HashMap<>());
 484         event.getAai().put("generic-vnf.vnf-name", "onsetOne");
 485
 486         ControlLoopEventManager manager = makeManager(event);
 487
 488         // Null YAML should fail
 489         VirtualControlLoopNotification notificationNull = manager.activate(null, event);
 490         assertNotNull(notificationNull);
 491         assertEquals(ControlLoopNotificationType.REJECTED, notificationNull.getNotification());
 492
 493         // Empty YAML should fail
 494         VirtualControlLoopNotification notificationEmpty = manager.activate("", event);
 495         assertNotNull(notificationEmpty);
 496         assertEquals(ControlLoopNotificationType.REJECTED, notificationEmpty.getNotification());
 497
 498         // Bad YAML should fail
 499         VirtualControlLoopNotification notificationBad = manager.activate(yamlStringBad, event);
 500         assertNotNull(notificationBad);
 501         assertEquals(ControlLoopNotificationType.REJECTED, notificationBad.getNotification());
 502
 503         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 504         assertNotNull(notification);
 505         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 506
 507         // Another activate should fail
 508         VirtualControlLoopNotification notificationActive = manager.activate(yamlString, event);
 509         assertNotNull(notificationActive);
 510         assertEquals(ControlLoopNotificationType.REJECTED, notificationActive.getNotification());
 511     }
 512
 513     @Test
 514     public void testControlLoopFinal() throws ControlLoopException, IOException {
 515         InputStream is = new FileInputStream(new File("src/test/resources/test.yaml"));
 516         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 517
 518         UUID requestId = UUID.randomUUID();
 519         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 520         event.setClosedLoopControlName("TwoOnsetTest");
 521         event.setRequestId(requestId);
 522         event.setTarget("generic-vnf.vnf-id");
 523         event.setClosedLoopAlarmStart(Instant.now());
 524         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 525         event.setAai(new HashMap<>());
 526         event.getAai().put("generic-vnf.vnf-name", "onsetOne");
 527
 528         ControlLoopEventManager manager = makeManager(event);
 529         try {
 530             manager.isControlLoopFinal();
 531             fail("test should throw an exception here");
 532         } catch (ControlLoopException e) {
 533             assertEquals("ControlLoopEventManager MUST be activated first.", e.getMessage());
 534         }
 535
 536         manager.setActivated(true);
 537         try {
 538             manager.isControlLoopFinal();
 539             fail("test should throw an exception here");
 540         } catch (ControlLoopException e) {
 541             assertEquals("No onset event for ControlLoopEventManager.", e.getMessage());
 542         }
 543
 544         manager.setActivated(false);
 545         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 546         assertNotNull(notification);
 547         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 548
 549         VirtualControlLoopNotification clfNotification = manager.isControlLoopFinal();
 550         assertNull(clfNotification);
 551
 552         manager.getProcessor().nextPolicyForResult(PolicyResult.SUCCESS);
 553         clfNotification = manager.isControlLoopFinal();
 554         assertNotNull(clfNotification);
 555         assertEquals(ControlLoopNotificationType.FINAL_SUCCESS, clfNotification.getNotification());
 556
 557         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 558         notification = manager.activate(yamlString, event);
 559         assertNotNull(notification);
 560         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 561
 562         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE_EXCEPTION);
 563         clfNotification = manager.isControlLoopFinal();
 564         assertNotNull(clfNotification);
 565         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 566
 567         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 568         notification = manager.activate(yamlString, event);
 569         assertNotNull(notification);
 570         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 571
 572         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE_GUARD);
 573         clfNotification = manager.isControlLoopFinal();
 574         assertNotNull(clfNotification);
 575         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 576
 577         manager.setControlLoopTimedOut();
 578         clfNotification = manager.isControlLoopFinal();
 579         assertNotNull(clfNotification);
 580         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 581     }
 582
 583     @Test
 584     public void testProcessControlLoop() throws ControlLoopException, IOException, AaiException {
 585         InputStream is = new FileInputStream(new File("src/test/resources/test.yaml"));
 586         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 587
 588         UUID requestId = UUID.randomUUID();
 589         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 590         event.setClosedLoopControlName("TwoOnsetTest");
 591         event.setRequestId(requestId);
 592         event.setTarget("generic-vnf.vnf-id");
 593         event.setClosedLoopAlarmStart(Instant.now());
 594         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 595         event.setAai(new HashMap<>());
 596         event.getAai().put("generic-vnf.vnf-name", "onsetOne");
 597
 598         ControlLoopEventManager manager = makeManager(event);
 599         try {
 600             manager.processControlLoop();
 601             fail("test should throw an exception here");
 602         } catch (Exception e) {
 603             assertEquals("ControlLoopEventManager MUST be activated first.", e.getMessage());
 604         }
 605
 606         manager.setActivated(true);
 607         try {
 608             manager.processControlLoop();
 609             fail("test should throw an exception here");
 610         } catch (Exception e) {
 611             assertEquals("No onset event for ControlLoopEventManager.", e.getMessage());
 612         }
 613
 614         manager.setActivated(false);
 615         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 616         assertNotNull(notification);
 617         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 618
 619         ControlLoopOperationManager clom = manager.processControlLoop();
 620         assertNotNull(clom);
 621         assertNull(clom.getOperationResult());
 622
 623         // Test operation in progress
 624         try {
 625             manager.processControlLoop();
 626             fail("test should throw an exception here");
 627         } catch (Exception e) {
 628             assertEquals("Already working an Operation, do not call this method.", e.getMessage());
 629         }
 630
 631         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 632         notification = manager.activate(yamlString, event);
 633         assertNotNull(notification);
 634         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 635
 636         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE_GUARD);
 637         VirtualControlLoopNotification clfNotification = manager.isControlLoopFinal();
 638         assertNotNull(clfNotification);
 639         assertEquals(ControlLoopNotificationType.FINAL_FAILURE, clfNotification.getNotification());
 640
 641         // Test operation completed
 642         try {
 643             manager.processControlLoop();
 644             fail("test should throw an exception here");
 645         } catch (Exception e) {
 646             assertEquals("Control Loop is in FINAL state, do not call this method.", e.getMessage());
 647         }
 648
 649         manager = new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
 650         notification = manager.activate(yamlString, event);
 651         assertNotNull(notification);
 652         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 653         manager.getProcessor().nextPolicyForResult(PolicyResult.FAILURE);
 654
 655         // Test operation with no next policy defined
 656         try {
 657             manager.processControlLoop();
 658             fail("test should throw an exception here");
 659         } catch (Exception e) {
 660             assertEquals("The target type is null", e.getMessage());
 661         }
 662     }
 663
 664     @Test
 665     public void testFinishOperation() throws IOException, ControlLoopException, AaiException {
 666         InputStream is = new FileInputStream(new File("src/test/resources/testSOactor.yaml"));
 667         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 668
 669         InputStream isStd = new FileInputStream(new File("src/test/resources/test.yaml"));
 670         final String yamlStringStd = IOUtils.toString(isStd, StandardCharsets.UTF_8);
 671
 672         UUID requestId = UUID.randomUUID();
 673         VirtualControlLoopEvent event = new VirtualControlLoopEvent();
 674         event.setClosedLoopControlName("TwoOnsetTest");
 675         event.setRequestId(requestId);
 676         event.setTarget("generic-vnf.vnf-id");
 677         event.setClosedLoopAlarmStart(Instant.now());
 678         event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 679         event.setAai(new HashMap<>());
 680         event.getAai().put("generic-vnf.vnf-id", "onsetOne");
 681
 682         ControlLoopEventManager manager = makeManager(event);
 683         try {
 684             manager.finishOperation(null);
 685             fail("test should throw an exception here");
 686         } catch (Exception e) {
 687             assertEquals("No operation to finish.", e.getMessage());
 688         }
 689
 690         manager.setActivated(true);
 691         try {
 692             manager.finishOperation(null);
 693             fail("test should throw an exception here");
 694         } catch (Exception e) {
 695             assertEquals("No operation to finish.", e.getMessage());
 696         }
 697
 698         manager.setActivated(false);
 699         VirtualControlLoopNotification notification = manager.activate(yamlString, event);
 700         assertNotNull(notification);
 701         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 702
 703         try {
 704             manager.lockCurrentOperation();
 705             fail("test should throw an exception here");
 706         } catch (Exception e) {
 707             assertEquals("Do not have a current operation.", e.getMessage());
 708         }
 709
 710         assertNull(manager.unlockCurrentOperation());
 711
 712         ControlLoopOperationManager clom = manager.processControlLoop();
 713         assertNotNull(clom);
 714         assertNull(clom.getOperationResult());
 715
 716         LockResult<GuardResult, TargetLock> lockLock = manager.lockCurrentOperation();
 717         assertNotNull(lockLock);
 718         assertEquals(GuardResult.LOCK_ACQUIRED, lockLock.getA());
 719
 720         LockResult<GuardResult, TargetLock> lockLockAgain = manager.lockCurrentOperation();
 721         assertNotNull(lockLockAgain);
 722         assertEquals(GuardResult.LOCK_ACQUIRED, lockLockAgain.getA());
 723         assertEquals(lockLock.getB(), lockLockAgain.getB());
 724
 725         assertEquals(lockLock.getB(), manager.unlockCurrentOperation());
 726         assertNull(manager.unlockCurrentOperation());
 727
 728         lockLock = manager.lockCurrentOperation();
 729         assertNotNull(lockLock);
 730         PolicyGuard.unlockTarget(lockLock.getB());
 731         assertEquals(lockLock.getB(), manager.unlockCurrentOperation());
 732
 733         clom.startOperation(event);
 734
 735         // This call should be exception free
 736         manager.finishOperation(clom);
 737
 738         ControlLoopEventManager otherManager = makeManager(event);
 739         VirtualControlLoopNotification otherNotification = otherManager.activate(yamlStringStd, event);
 740         assertNotNull(otherNotification);
 741         assertEquals(ControlLoopNotificationType.ACTIVE, otherNotification.getNotification());
 742
 743         ControlLoopOperationManager otherClom = otherManager.processControlLoop();
 744         assertNotNull(otherClom);
 745         assertNull(otherClom.getOperationResult());
 746
 747         otherManager.finishOperation(clom);
 748     }
 749
 750     @Test
 751     public void testOnNewEvent() throws IOException, AaiException {
 752         InputStream is = new FileInputStream(new File("src/test/resources/test.yaml"));
 753         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 754
 755         UUID requestId = UUID.randomUUID();
 756         VirtualControlLoopEvent onsetEvent = new VirtualControlLoopEvent();
 757         onsetEvent.setClosedLoopControlName("TwoOnsetTest");
 758         onsetEvent.setRequestId(requestId);
 759         onsetEvent.setTarget("generic-vnf.vnf-id");
 760         onsetEvent.setClosedLoopAlarmStart(Instant.now());
 761         onsetEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 762         onsetEvent.setAai(new HashMap<>());
 763         onsetEvent.getAai().put("generic-vnf.vnf-name", "onsetOne");
 764
 765         VirtualControlLoopEvent abatedEvent = new VirtualControlLoopEvent();
 766         abatedEvent.setClosedLoopControlName("TwoOnsetTest");
 767         abatedEvent.setRequestId(requestId);
 768         abatedEvent.setTarget("generic-vnf.vnf-id");
 769         abatedEvent.setClosedLoopAlarmStart(Instant.now());
 770         abatedEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ABATED);
 771         abatedEvent.setAai(new HashMap<>());
 772         abatedEvent.getAai().put("generic-vnf.vnf-name", "onsetOne");
 773
 774         ControlLoopEventManager manager = makeManager(onsetEvent);
 775         VirtualControlLoopNotification notification = manager.activate(yamlString, onsetEvent);
 776         assertNotNull(notification);
 777         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 778
 779         assertEquals(NEW_EVENT_STATUS.FIRST_ONSET, manager.onNewEvent(onsetEvent));
 780         assertEquals(NEW_EVENT_STATUS.FIRST_ABATEMENT, manager.onNewEvent(abatedEvent));
 781         assertEquals(NEW_EVENT_STATUS.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 782
 783         VirtualControlLoopEvent checkSyntaxEvent = new VirtualControlLoopEvent();
 784         checkSyntaxEvent.setAai(null);
 785         checkSyntaxEvent.setClosedLoopAlarmEnd(null);
 786         checkSyntaxEvent.setClosedLoopAlarmStart(null);
 787         checkSyntaxEvent.setClosedLoopControlName(null);
 788         checkSyntaxEvent.setClosedLoopEventClient(null);
 789         checkSyntaxEvent.setClosedLoopEventStatus(null);
 790         checkSyntaxEvent.setFrom(null);
 791         checkSyntaxEvent.setPolicyName(null);
 792         checkSyntaxEvent.setPolicyScope(null);
 793         checkSyntaxEvent.setPolicyVersion(null);
 794         checkSyntaxEvent.setRequestId(null);
 795         checkSyntaxEvent.setTarget(null);
 796         checkSyntaxEvent.setTargetType(null);
 797         checkSyntaxEvent.setVersion(null);
 798
 799         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 800
 801         checkSyntaxEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 802         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 803
 804         checkSyntaxEvent.setClosedLoopControlName(null);
 805         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 806
 807         checkSyntaxEvent.setClosedLoopControlName("");
 808         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 809
 810         checkSyntaxEvent.setClosedLoopControlName("TwoOnsetTest");
 811         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 812
 813         checkSyntaxEvent.setRequestId(null);
 814         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 815
 816         checkSyntaxEvent.setRequestId(requestId);
 817         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 818
 819         checkSyntaxEvent.setAai(null);
 820         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 821
 822         checkSyntaxEvent.setAai(new HashMap<>());
 823         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 824
 825         checkSyntaxEvent.setTarget("");
 826         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 827
 828         checkSyntaxEvent.setTarget(null);
 829         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 830
 831         checkSyntaxEvent.setTarget("");
 832         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 833
 834         checkSyntaxEvent.setTarget("OZ");
 835         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 836
 837         checkSyntaxEvent.setTarget("VM_NAME");
 838         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 839
 840         checkSyntaxEvent.setTarget("VNF_NAME");
 841         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 842
 843         checkSyntaxEvent.setTarget("vserver.vserver-name");
 844         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 845
 846         checkSyntaxEvent.setTarget("generic-vnf.vnf-id");
 847         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 848
 849         checkSyntaxEvent.setTarget("generic-vnf.vnf-name");
 850         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 851
 852         checkSyntaxEvent.setAai(null);
 853         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 854
 855         checkSyntaxEvent.setAai(new HashMap<>());
 856         assertEquals(NEW_EVENT_STATUS.SYNTAX_ERROR, manager.onNewEvent(checkSyntaxEvent));
 857
 858         checkSyntaxEvent.getAai().put("generic-vnf.vnf-name", "onsetOne");
 859         assertEquals(NEW_EVENT_STATUS.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 860
 861         checkSyntaxEvent.getAai().put("vserver.vserver-name", "onsetOne");
 862         assertEquals(NEW_EVENT_STATUS.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 863
 864         checkSyntaxEvent.getAai().put("generic-vnf.vnf-id", "onsetOne");
 865         assertEquals(NEW_EVENT_STATUS.SUBSEQUENT_ABATEMENT, manager.onNewEvent(abatedEvent));
 866     }
 867
 868     @Test
 869     public void testControlLoopTimeout() throws IOException {
 870         InputStream is = new FileInputStream(new File("src/test/resources/test.yaml"));
 871         final String yamlString = IOUtils.toString(is, StandardCharsets.UTF_8);
 872
 873         UUID requestId = UUID.randomUUID();
 874         VirtualControlLoopEvent onsetEvent = new VirtualControlLoopEvent();
 875         onsetEvent.setClosedLoopControlName("TwoOnsetTest");
 876         onsetEvent.setRequestId(requestId);
 877         onsetEvent.setTarget("generic-vnf.vnf-id");
 878         onsetEvent.setClosedLoopAlarmStart(Instant.now());
 879         onsetEvent.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET);
 880         onsetEvent.setAai(new HashMap<>());
 881         onsetEvent.getAai().put("generic-vnf.vnf-name", "onsetOne");
 882
 883         ControlLoopEventManager manager = makeManager(onsetEvent);
 884         assertTrue(0 == manager.getControlLoopTimeout(null));
 885         assertTrue(120 == manager.getControlLoopTimeout(120));
 886
 887         VirtualControlLoopNotification notification = manager.activate(yamlString, onsetEvent);
 888         assertNotNull(notification);
 889         assertEquals(ControlLoopNotificationType.ACTIVE, notification.getNotification());
 890
 891         assertTrue(60 == manager.getControlLoopTimeout(null));
 892     }
 893
 894     @Test
 895     public void testQueryAai_AlreadyDisabled() throws AaiException {
 896         ControlLoopEventManager mgr = null;
 897
 898         try {
 899             onset.getAai().put(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED, Boolean.TRUE.toString());
 900             onset.getAai().put(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS,
 901                             ControlLoopEventManager.PROV_STATUS_ACTIVE);
 902
 903             mgr = makeManager(onset);
 904             mgr.queryAai(onset);
 905
 906             fail("missing exception");
 907
 908         } catch (AaiException expected) {
 909             assertEquals("is-closed-loop-disabled is set to true on VServer or VNF", expected.getMessage());
 910             assertNull(mgr.getVnfResponse());
 911             assertNull(mgr.getVserverResponse());
 912         }
 913     }
 914
 915     @Test
 916     public void testQueryAai_AlreadyInactive() throws AaiException {
 917         ControlLoopEventManager mgr = null;
 918
 919         try {
 920             onset.getAai().put(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED, Boolean.FALSE.toString());
 921             onset.getAai().put(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS, "not-active2");
 922
 923             mgr = makeManager(onset);
 924             mgr.queryAai(onset);
 925
 926             fail("missing exception");
 927
 928         } catch (AaiException expected) {
 929             assertEquals("prov-status is not ACTIVE on VServer or VNF", expected.getMessage());
 930             assertNull(mgr.getVnfResponse());
 931             assertNull(mgr.getVserverResponse());
 932         }
 933     }
 934
 935     @Test
 936     public void testQueryAai_QueryVnfById() throws AaiException {
 937         ControlLoopEventManager mgr = null;
 938
 939         mgr = makeManager(onset);
 940         mgr.queryAai(onset);
 941
 942         assertNotNull(mgr.getVnfResponse());
 943         assertNull(mgr.getVserverResponse());
 944
 945         AaiGetVnfResponse vnfresp = mgr.getVnfResponse();
 946
 947         // should not re-query
 948         mgr.queryAai(onset);
 949
 950         assertEquals(vnfresp, mgr.getVnfResponse());
 951         assertNull(mgr.getVserverResponse());
 952     }
 953
 954     @Test
 955     public void testQueryAai_QueryVnfByName() throws AaiException {
 956         ControlLoopEventManager mgr = null;
 957
 958         // vnf query by name
 959         onset.getAai().remove(ControlLoopEventManager.GENERIC_VNF_VNF_ID);
 960         onset.getAai().put(ControlLoopEventManager.GENERIC_VNF_VNF_NAME, "AVNFName");
 961
 962         mgr = makeManager(onset);
 963         mgr.queryAai(onset);
 964
 965         assertNotNull(mgr.getVnfResponse());
 966         assertNull(mgr.getVserverResponse());
 967
 968         AaiGetVnfResponse vnfresp = mgr.getVnfResponse();
 969
 970         // should not re-query
 971         mgr.queryAai(onset);
 972
 973         assertEquals(vnfresp, mgr.getVnfResponse());
 974         assertNull(mgr.getVserverResponse());
 975     }
 976
 977     @Test
 978     public void testQueryAai_QueryVnfById_Disabled() throws AaiException {
 979         ControlLoopEventManager mgr = null;
 980
 981         try {
 982             onset.getAai().put(ControlLoopEventManager.GENERIC_VNF_VNF_ID, "disableClosedLoop");
 983
 984             mgr = makeManager(onset);
 985             mgr.queryAai(onset);
 986
 987             fail("missing exception");
 988
 989         } catch (AaiException expected) {
 990             assertEquals("is-closed-loop-disabled is set to true (query by vnf-id)", expected.getMessage());
 991
 992             assertNotNull(mgr.getVnfResponse());
 993             assertNull(mgr.getVserverResponse());
 994         }
 995     }
 996
 997     @Test
 998     public void testQueryAai_QueryVserver() throws AaiException {
 999         ControlLoopEventManager mgr = null;
1000
1001         onset.getAai().remove(ControlLoopEventManager.GENERIC_VNF_VNF_ID);
1002         onset.getAai().put(ControlLoopEventManager.VSERVER_VSERVER_NAME, "AVserver");
1003
1004         mgr = makeManager(onset);
1005         mgr.queryAai(onset);
1006
1007         assertNull(mgr.getVnfResponse());
1008         assertNotNull(mgr.getVserverResponse());
1009
1010         AaiGetVserverResponse vsvresp = mgr.getVserverResponse();
1011
1012         // should not re-query
1013         mgr.queryAai(onset);
1014
1015         assertNull(mgr.getVnfResponse());
1016         assertEquals(vsvresp, mgr.getVserverResponse());
1017     }
1018
1019     @Test
1020     public void testQueryAai_QueryVserver_Disabled() throws AaiException {
1021         ControlLoopEventManager mgr = null;
1022
1023         try {
1024             onset.getAai().remove(ControlLoopEventManager.GENERIC_VNF_VNF_ID);
1025             onset.getAai().put(ControlLoopEventManager.VSERVER_VSERVER_NAME, "disableClosedLoop");
1026
1027             mgr = makeManager(onset);
1028             mgr.queryAai(onset);
1029
1030             fail("missing exception");
1031
1032         } catch (AaiException expected) {
1033             assertEquals("is-closed-loop-disabled is set to true (query by vserver-name)", expected.getMessage());
1034
1035             assertNull(mgr.getVnfResponse());
1036             assertNotNull(mgr.getVserverResponse());
1037         }
1038     }
1039
1040     @Test(expected = AaiException.class)
1041     public void testQueryAai_QueryException() throws AaiException {
1042         // Force AAI errors
1043         PolicyEngine.manager.setEnvironmentProperty("aai.url", "http://localhost:9999");
1044
1045         makeManager(onset).queryAai(onset);
1046     }
1047
1048     @Test
1049     public void testProcessVNFResponse_Success() throws Exception {
1050         AaiGetVnfResponse resp = new AaiGetVnfResponse();
1051         resp.setIsClosedLoopDisabled(false);
1052         resp.setProvStatus(ControlLoopEventManager.PROV_STATUS_ACTIVE);
1053         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVNFResponse", resp, true);
1054     }
1055
1056     @Test
1057     public void testProcessVNFResponse_NullResponse() throws Exception {
1058         thrown.expect(AaiException.class);
1059         thrown.expectMessage("AAI Response is null (query by vnf-id)");
1060
1061         AaiGetVnfResponse resp = null;
1062         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVNFResponse", resp, true);
1063     }
1064
1065     @Test
1066     public void testProcessVNFResponse_Error() throws Exception {
1067         thrown.expect(AaiException.class);
1068         thrown.expectMessage("AAI Responded with a request error (query by vnf-name)");
1069
1070         AaiGetVnfResponse resp = new AaiGetVnfResponse();
1071
1072         resp.setRequestError(new AaiNqRequestError());
1073
1074         resp.setIsClosedLoopDisabled(false);
1075         resp.setProvStatus(ControlLoopEventManager.PROV_STATUS_ACTIVE);
1076         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVNFResponse", resp, false);
1077     }
1078
1079     @Test
1080     public void testProcessVNFResponse_Disabled() throws Exception {
1081         thrown.expect(AaiException.class);
1082         thrown.expectMessage("is-closed-loop-disabled is set to true (query by vnf-id)");
1083
1084         AaiGetVnfResponse resp = new AaiGetVnfResponse();
1085         resp.setIsClosedLoopDisabled(true);
1086         resp.setProvStatus(ControlLoopEventManager.PROV_STATUS_ACTIVE);
1087         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVNFResponse", resp, true);
1088     }
1089
1090     @Test
1091     public void testProcessVNFResponse_Inactive() throws Exception {
1092         thrown.expect(AaiException.class);
1093         thrown.expectMessage("prov-status is not ACTIVE (query by vnf-name)");
1094
1095         AaiGetVnfResponse resp = new AaiGetVnfResponse();
1096         resp.setIsClosedLoopDisabled(false);
1097         resp.setProvStatus("inactive1");
1098         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVNFResponse", resp, false);
1099     }
1100
1101     @Test
1102     public void testProcessVserverResponse_Success() throws Exception {
1103         AaiGetVserverResponse resp = new AaiGetVserverResponse();
1104
1105         AaiNqVServer svr = new AaiNqVServer();
1106         resp.getVserver().add(svr);
1107
1108         svr.setIsClosedLoopDisabled(false);
1109         svr.setProvStatus(ControlLoopEventManager.PROV_STATUS_ACTIVE);
1110         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVServerResponse", resp);
1111     }
1112
1113     @Test
1114     public void testProcessVserverResponse_NullResponse() throws Exception {
1115         thrown.expect(AaiException.class);
1116         thrown.expectMessage("AAI Response is null (query by vserver-name)");
1117
1118         AaiGetVserverResponse resp = null;
1119         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVServerResponse", resp);
1120     }
1121
1122     @Test
1123     public void testProcessVserverResponse_Error() throws Exception {
1124         thrown.expect(AaiException.class);
1125         thrown.expectMessage("AAI Responded with a request error (query by vserver-name)");
1126
1127         AaiGetVserverResponse resp = new AaiGetVserverResponse();
1128
1129         resp.setRequestError(new AaiNqRequestError());
1130
1131         AaiNqVServer svr = new AaiNqVServer();
1132         resp.getVserver().add(svr);
1133
1134         svr.setIsClosedLoopDisabled(false);
1135         svr.setProvStatus(ControlLoopEventManager.PROV_STATUS_ACTIVE);
1136
1137         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVServerResponse", resp);
1138     }
1139
1140     @Test
1141     public void testProcessVserverResponse_Disabled() throws Exception {
1142         thrown.expect(AaiException.class);
1143         thrown.expectMessage("is-closed-loop-disabled is set to true (query by vserver-name)");
1144
1145         AaiGetVserverResponse resp = new AaiGetVserverResponse();
1146         AaiNqVServer svr = new AaiNqVServer();
1147         resp.getVserver().add(svr);
1148
1149         svr.setIsClosedLoopDisabled(true);
1150         svr.setProvStatus(ControlLoopEventManager.PROV_STATUS_ACTIVE);
1151         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVServerResponse", resp);
1152     }
1153
1154     @Test
1155     public void testProcessVserverResponse_Inactive() throws Exception {
1156         thrown.expect(AaiException.class);
1157         thrown.expectMessage("prov-status is not ACTIVE (query by vserver-name)");
1158
1159         AaiGetVserverResponse resp = new AaiGetVserverResponse();
1160         AaiNqVServer svr = new AaiNqVServer();
1161         resp.getVserver().add(svr);
1162
1163         svr.setIsClosedLoopDisabled(false);
1164         svr.setProvStatus("inactive1");
1165         Whitebox.invokeMethod(ControlLoopEventManager.class, "processVServerResponse", resp);
1166     }
1167
1168     @Test
1169     public void testIsClosedLoopDisabled() {
1170         Map<String, String> aai = onset.getAai();
1171
1172         // null, null
1173         aai.remove(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED);
1174         aai.remove(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED);
1175         assertFalse(ControlLoopEventManager.isClosedLoopDisabled(onset));
1176
1177         // null, false
1178         aai.remove(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED);
1179         aai.put(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED, Boolean.FALSE.toString());
1180         assertFalse(ControlLoopEventManager.isClosedLoopDisabled(onset));
1181
1182         // false, null
1183         aai.put(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED, Boolean.FALSE.toString());
1184         aai.remove(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED);
1185         assertFalse(ControlLoopEventManager.isClosedLoopDisabled(onset));
1186
1187         // null, true
1188         aai.remove(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED);
1189         aai.put(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED, Boolean.TRUE.toString());
1190         assertTrue(ControlLoopEventManager.isClosedLoopDisabled(onset));
1191
1192         // true, null
1193         aai.put(ControlLoopEventManager.GENERIC_VNF_IS_CLOSED_LOOP_DISABLED, Boolean.TRUE.toString());
1194         aai.remove(ControlLoopEventManager.VSERVER_IS_CLOSED_LOOP_DISABLED);
1195         assertTrue(ControlLoopEventManager.isClosedLoopDisabled(onset));
1196     }
1197
1198     @Test
1199     public void testIsProvStatusInactive() {
1200         Map<String, String> aai = onset.getAai();
1201
1202         // null, null
1203         aai.remove(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS);
1204         aai.remove(ControlLoopEventManager.VSERVER_PROV_STATUS);
1205         assertFalse(ControlLoopEventManager.isProvStatusInactive(onset));
1206
1207         // null, active
1208         aai.remove(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS);
1209         aai.put(ControlLoopEventManager.VSERVER_PROV_STATUS, ControlLoopEventManager.PROV_STATUS_ACTIVE);
1210         assertFalse(ControlLoopEventManager.isProvStatusInactive(onset));
1211
1212         // active, null
1213         aai.put(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS, ControlLoopEventManager.PROV_STATUS_ACTIVE);
1214         aai.remove(ControlLoopEventManager.VSERVER_PROV_STATUS);
1215         assertFalse(ControlLoopEventManager.isProvStatusInactive(onset));
1216
1217         // null, inactive
1218         aai.remove(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS);
1219         aai.put(ControlLoopEventManager.VSERVER_PROV_STATUS, "other1");
1220         assertTrue(ControlLoopEventManager.isProvStatusInactive(onset));
1221
1222         // inactive, null
1223         aai.put(ControlLoopEventManager.GENERIC_VNF_PROV_STATUS, "other2");
1224         aai.remove(ControlLoopEventManager.VSERVER_PROV_STATUS);
1225         assertTrue(ControlLoopEventManager.isProvStatusInactive(onset));
1226     }
1227
1228     @Test
1229     public void testIsAaiTrue() {
1230         assertTrue(ControlLoopEventManager.isAaiTrue("tRuE"));
1231         assertTrue(ControlLoopEventManager.isAaiTrue("T"));
1232         assertTrue(ControlLoopEventManager.isAaiTrue("t"));
1233         assertTrue(ControlLoopEventManager.isAaiTrue("yES"));
1234         assertTrue(ControlLoopEventManager.isAaiTrue("Y"));
1235         assertTrue(ControlLoopEventManager.isAaiTrue("y"));
1236
1237         assertFalse(ControlLoopEventManager.isAaiTrue("no"));
1238         assertFalse(ControlLoopEventManager.isAaiTrue(null));
1239     }
1240
1241     private ControlLoopEventManager makeManager(VirtualControlLoopEvent event) {
1242         return new ControlLoopEventManager(event.getClosedLoopControlName(), event.getRequestId());
1243     }
1244 }