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