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