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