alivenessmonitor/alivenessmonitor-impl-protocols/src/test/java/org/opendaylight/genius/alivenessmonitor/protocols/test/AlivenessMonitorTest.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.genius.alivenessmonitor.protocols.test;
   9
  10 import static org.hamcrest.MatcherAssert.assertThat;
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.Matchers.any;
  15 import static org.mockito.Matchers.argThat;
  16 import static org.mockito.Matchers.eq;
  17 import static org.mockito.Mockito.doNothing;
  18 import static org.mockito.Mockito.doReturn;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.verify;
  21 import static org.mockito.Mockito.when;
  22
  23 import com.google.common.util.concurrent.FluentFuture;
  24 import com.google.common.util.concurrent.Futures;
  25 import java.util.Arrays;
  26 import java.util.Optional;
  27 import java.util.concurrent.ExecutionException;
  28 import org.hamcrest.CoreMatchers;
  29 import org.hamcrest.Description;
  30 import org.hamcrest.Matcher;
  31 import org.hamcrest.TypeSafeMatcher;
  32 import org.junit.After;
  33 import org.junit.Before;
  34 import org.junit.Test;
  35 import org.mockito.ArgumentCaptor;
  36 import org.mockito.Captor;
  37 import org.mockito.Matchers;
  38 import org.mockito.Mock;
  39 import org.mockito.MockitoAnnotations;
  40 import org.opendaylight.genius.alivenessmonitor.internal.AlivenessMonitor;
  41 import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandler;
  42 import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandlerRegistry;
  43 import org.opendaylight.genius.alivenessmonitor.protocols.impl.AlivenessProtocolHandlerRegistryImpl;
  44 import org.opendaylight.genius.alivenessmonitor.protocols.internal.AlivenessProtocolHandlerARP;
  45 import org.opendaylight.genius.alivenessmonitor.protocols.internal.AlivenessProtocolHandlerLLDP;
  46 import org.opendaylight.mdsal.binding.api.DataBroker;
  47 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  48 import org.opendaylight.mdsal.binding.api.NotificationService;
  49 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  50 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
  51 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  52 import org.opendaylight.mdsal.common.api.CommitInfo;
  53 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorPauseInput;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorPauseInputBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateInput;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateInputBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateOutput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInput;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInputBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteOutput;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProtocolType;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartInput;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartInputBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartOutput;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStatus;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInput;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInputBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopOutput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseInput;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseInputBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorUnpauseOutput;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitoringMode;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411._interface.monitor.map.InterfaceMonitorEntry;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411._interface.monitor.map.InterfaceMonitorEntryBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.endpoint.endpoint.type.Interface;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.endpoint.endpoint.type.InterfaceBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.configs.MonitoringInfo;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.configs.MonitoringInfoBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.params.DestinationBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.params.SourceBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.ProfileBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profiles.MonitorProfile;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profiles.MonitorProfileBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.start.input.ConfigBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitorid.key.map.MonitoridKeyEntry;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitorid.key.map.MonitoridKeyEntryBuilder;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitoring.states.MonitoringState;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitoring.states.MonitoringStateBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutputBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
 101 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 102 import org.opendaylight.yangtools.yang.binding.DataObject;
 103 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 104 import org.opendaylight.yangtools.yang.common.RpcError;
 105 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
 106 import org.opendaylight.yangtools.yang.common.RpcResult;
 107 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 108 import org.opendaylight.yangtools.yang.common.Uint32;
 109
 110 public class AlivenessMonitorTest {
 111
 112     @Mock
 113     private DataBroker dataBroker;
 114     @Mock
 115     private IdManagerService idManager;
 116     @Mock
 117     private PacketProcessingService packetProcessingService;
 118     @Mock
 119     private NotificationPublishService notificationPublishService;
 120     @Mock
 121     private NotificationService notificationService;
 122     @Mock
 123     private OdlInterfaceRpcService interfaceManager;
 124     @Mock
 125     private OdlArputilService arpService;
 126     private AlivenessMonitor alivenessMonitor;
 127     private AlivenessProtocolHandler<?> arpHandler;
 128     private AlivenessProtocolHandler<?> lldpHandler;
 129     private long mockId;
 130     @Mock
 131     private ReadTransaction readTx;
 132     @Mock
 133     private WriteTransaction writeTx;
 134     @Mock
 135     private ReadWriteTransaction readWriteTx;
 136     @Captor
 137     ArgumentCaptor<MonitoringState> stateCaptor;
 138
 139     private <T extends DataObject> Matcher<InstanceIdentifier<T>> isType(
 140             final Class<T> klass) {
 141         return new TypeSafeMatcher<>() {
 142             @Override
 143             public void describeTo(Description desc) {
 144                 desc.appendText(
 145                         "Instance Identifier should have Target Type " + klass);
 146             }
 147
 148             @Override
 149             protected boolean matchesSafely(InstanceIdentifier<T> id) {
 150                 return id.getTargetType().equals(klass);
 151             }
 152         };
 153     }
 154
 155     private Matcher<RpcError> hasErrorType(final ErrorType errorType) {
 156         return new TypeSafeMatcher<>() {
 157             @Override
 158             public void describeTo(Description desc) {
 159                 desc.appendText("Error type do not match " + errorType);
 160             }
 161
 162             @Override
 163             protected boolean matchesSafely(RpcError error) {
 164                 return error.getErrorType().equals(errorType);
 165             }
 166         };
 167     }
 168
 169     @SuppressWarnings("unchecked")
 170     @Before
 171     public void setUp() {
 172         MockitoAnnotations.initMocks(this);
 173         when(idManager.createIdPool(any(CreateIdPoolInput.class)))
 174                 .thenReturn(Futures.immediateFuture(
 175                         RpcResultBuilder.<CreateIdPoolOutput>success().build()));
 176
 177         AlivenessProtocolHandlerRegistry alivenessProtocolHandlerRegistry = new AlivenessProtocolHandlerRegistryImpl();
 178         alivenessMonitor = new AlivenessMonitor(dataBroker, idManager,
 179                 notificationPublishService, alivenessProtocolHandlerRegistry);
 180         arpHandler = new AlivenessProtocolHandlerARP(dataBroker, alivenessProtocolHandlerRegistry,
 181                 interfaceManager, arpService);
 182         lldpHandler = new AlivenessProtocolHandlerLLDP(dataBroker,
 183                 alivenessProtocolHandlerRegistry, packetProcessingService);
 184         mockId = 1L;
 185         when(idManager.allocateId(any(AllocateIdInput.class)))
 186                 .thenReturn(
 187                         Futures.immediateFuture(RpcResultBuilder
 188                                 .success(new AllocateIdOutputBuilder()
 189                                         .setIdValue(Uint32.valueOf(mockId++)).build())
 190                                 .build()));
 191         when(idManager.releaseId(any(ReleaseIdInput.class))).thenReturn(Futures
 192                 .immediateFuture(RpcResultBuilder.<ReleaseIdOutput>success().build()));
 193         doReturn(readTx).when(dataBroker).newReadOnlyTransaction();
 194         doReturn(writeTx).when(dataBroker).newWriteOnlyTransaction();
 195         doReturn(readWriteTx).when(dataBroker).newReadWriteTransaction();
 196         doNothing().when(writeTx).put(eq(LogicalDatastoreType.OPERATIONAL),
 197                 any(InstanceIdentifier.class), any(DataObject.class));
 198         doReturn(FluentFutures.immediateNullFluentFuture()).when(writeTx).commit();
 199         doReturn(FluentFutures.immediateNullFluentFuture()).when(readWriteTx).commit();
 200     }
 201
 202     @After
 203     public void tearDown() {
 204         alivenessMonitor.close();
 205     }
 206
 207     @Test
 208     public void testMonitorProfileCreate()
 209             throws InterruptedException, ExecutionException {
 210         MonitorProfileCreateInput input = new MonitorProfileCreateInputBuilder()
 211                 .setProfile(new ProfileBuilder().setFailureThreshold(Uint32.TEN)
 212                         .setMonitorInterval(Uint32.valueOf(10000)).setMonitorWindow(Uint32.TEN)
 213                         .setProtocolType(MonitorProtocolType.Arp).build())
 214                 .build();
 215         doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
 216                 .when(readWriteTx).read(eq(LogicalDatastoreType.OPERATIONAL),
 217                         argThat(isType(MonitorProfile.class)));
 218         doReturn(FluentFutures.immediateNullFluentFuture()).when(readWriteTx).commit();
 219         RpcResult<MonitorProfileCreateOutput> output = alivenessMonitor
 220                 .monitorProfileCreate(input).get();
 221         assertTrue("Monitor Profile Create result", output.isSuccessful());
 222         assertNotNull("Monitor Profile Output",
 223                 output.getResult().getProfileId());
 224     }
 225
 226     @Test
 227     public void testMonitorProfileCreateAlreadyExist()
 228             throws InterruptedException, ExecutionException {
 229         MonitorProfileCreateInput input = new MonitorProfileCreateInputBuilder()
 230                 .setProfile(new ProfileBuilder().setFailureThreshold(Uint32.TEN)
 231                         .setMonitorInterval(Uint32.valueOf(10000)).setMonitorWindow(Uint32.TEN)
 232                         .setProtocolType(MonitorProtocolType.Arp).build())
 233                 .build();
 234         doReturn(FluentFutures.immediateFluentFuture(Optional.of(input))).when(readWriteTx).read(
 235                 eq(LogicalDatastoreType.OPERATIONAL),
 236                 argThat(isType(MonitorProfile.class)));
 237         RpcResult<MonitorProfileCreateOutput> output = alivenessMonitor
 238                 .monitorProfileCreate(input).get();
 239         assertTrue("Monitor Profile Create result", output.isSuccessful());
 240         assertThat(output.getErrors(),
 241                 CoreMatchers.hasItem(hasErrorType(ErrorType.PROTOCOL)));
 242     }
 243
 244     @Test
 245     public void testMonitorStart()
 246             throws InterruptedException, ExecutionException {
 247         Uint32 profileId = createProfile();
 248         MonitorStartInput input = new MonitorStartInputBuilder()
 249                 .setConfig(
 250                         new ConfigBuilder()
 251                                 .setDestination(new DestinationBuilder()
 252                                         .setEndpointType(
 253                                                 getInterface("10.0.0.1"))
 254                                         .build())
 255                                 .setSource(new SourceBuilder()
 256                                         .setEndpointType(getInterface(
 257                                                 "testInterface", "10.1.1.1"))
 258                                         .build())
 259                                 .setMode(MonitoringMode.OneOne)
 260                                 .setProfileId(profileId).build())
 261                 .build();
 262         Optional<MonitorProfile> optionalProfile = Optional.of(getTestMonitorProfile());
 263         FluentFuture<Optional<MonitorProfile>> proFuture =
 264             FluentFutures.immediateFluentFuture(optionalProfile);
 265         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 266                 argThat(isType(MonitorProfile.class)))).thenReturn(proFuture);
 267         FluentFuture<Optional<MonitoringInfo>> outFuture = FluentFutures
 268                 .immediateFluentFuture(Optional.<MonitoringInfo>empty());
 269         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 270                 argThat(isType(MonitoringInfo.class)))).thenReturn(outFuture);
 271         RpcResult<MonitorStartOutput> output = alivenessMonitor
 272                 .monitorStart(input).get();
 273         verify(idManager, times(2)).allocateId(any(AllocateIdInput.class));
 274         assertTrue("Monitor start output result", output.isSuccessful());
 275         assertNotNull("Monitor start output",
 276                 output.getResult().getMonitorId());
 277     }
 278
 279     @Test
 280     public void testMonitorPause()
 281             throws InterruptedException, ExecutionException {
 282         MonitorPauseInput input = new MonitorPauseInputBuilder()
 283                 .setMonitorId(Uint32.TWO).build();
 284         Optional<MonitorProfile> optProfile = Optional
 285                 .of(getTestMonitorProfile());
 286         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 287                 argThat(isType(MonitorProfile.class))))
 288                         .thenReturn(FluentFutures.immediateFluentFuture(optProfile));
 289         Optional<MonitoringInfo> optInfo = Optional.of(
 290                 new MonitoringInfoBuilder().setId(Uint32.TWO).setProfileId(Uint32.ONE).build());
 291         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 292                 argThat(isType(MonitoringInfo.class))))
 293                         .thenReturn(FluentFutures.immediateFluentFuture(optInfo));
 294         Optional<MonitoringState> optState = Optional
 295                 .of(new MonitoringStateBuilder().setMonitorKey("foo")
 296                         .setStatus(MonitorStatus.Started).build());
 297         when(readWriteTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 298                 argThat(isType(MonitoringState.class))))
 299                         .thenReturn(FluentFutures.immediateFluentFuture(optState));
 300         Optional<MonitoridKeyEntry> optMap = Optional
 301                 .of(new MonitoridKeyEntryBuilder().setMonitorId(Uint32.TWO)
 302                         .setMonitorKey("Test monitor Key").build());
 303         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 304                 argThat(isType(MonitoridKeyEntry.class))))
 305                         .thenReturn(FluentFutures.immediateFluentFuture(optMap));
 306         alivenessMonitor.monitorPause(input).get();
 307         verify(readWriteTx).merge(eq(LogicalDatastoreType.OPERATIONAL),
 308                 argThat(isType(MonitoringState.class)), stateCaptor.capture());
 309         assertEquals(MonitorStatus.Paused, stateCaptor.getValue().getStatus());
 310     }
 311
 312     @Test
 313     public void testMonitorUnpause()
 314             throws InterruptedException, ExecutionException {
 315         MonitorUnpauseInput input = new MonitorUnpauseInputBuilder()
 316                 .setMonitorId(Uint32.TWO).build();
 317         Optional<MonitoringState> optState = Optional
 318                 .of(new MonitoringStateBuilder().setMonitorKey("foo").setStatus(MonitorStatus.Paused)
 319                         .build());
 320         when(readWriteTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 321                 argThat(isType(MonitoringState.class))))
 322                         .thenReturn(FluentFutures.immediateFluentFuture(optState));
 323         Optional<MonitoringInfo> optInfo = Optional.of(
 324                 new MonitoringInfoBuilder().setId(Uint32.TWO).setProfileId(Uint32.ONE).build());
 325         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 326                 argThat(isType(MonitoringInfo.class))))
 327                         .thenReturn(FluentFutures.immediateFluentFuture(optInfo));
 328         Optional<MonitorProfile> optProfile = Optional
 329                 .of(getTestMonitorProfile());
 330         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 331                 argThat(isType(MonitorProfile.class))))
 332                         .thenReturn(FluentFutures.immediateFluentFuture(optProfile));
 333         Optional<MonitoridKeyEntry> optMap = Optional
 334                 .of(new MonitoridKeyEntryBuilder().setMonitorId(Uint32.TWO)
 335                         .setMonitorKey("Test monitor Key").build());
 336         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 337                 argThat(isType(MonitoridKeyEntry.class))))
 338                         .thenReturn(FluentFutures.immediateFluentFuture(optMap));
 339         RpcResult<MonitorUnpauseOutput> result = alivenessMonitor.monitorUnpause(input).get();
 340         verify(readWriteTx).merge(eq(LogicalDatastoreType.OPERATIONAL),
 341                 argThat(isType(MonitoringState.class)), stateCaptor.capture());
 342         assertEquals(MonitorStatus.Started, stateCaptor.getValue().getStatus());
 343         assertTrue("Monitor unpause rpc result", result.isSuccessful());
 344     }
 345
 346     @Test
 347     public void testMonitorStop()
 348             throws InterruptedException, ExecutionException {
 349         MonitorStopInput input = new MonitorStopInputBuilder().setMonitorId(Uint32.TWO).build();
 350         Optional<MonitoringInfo> optInfo = Optional
 351                 .of(new MonitoringInfoBuilder().setId(Uint32.MAX_VALUE).setSource(new SourceBuilder()
 352                         .setEndpointType(getInterface("testInterface", "10.1.1.1"))
 353                         .build()).setProfileId(Uint32.ZERO).build());
 354         FluentFuture<Optional<MonitoringInfo>> outFuture = FluentFutures.immediateFluentFuture(optInfo);
 355         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 356                 argThat(isType(MonitoringInfo.class)))).thenReturn(outFuture);
 357         Optional<MonitoridKeyEntry> optMap = Optional
 358                 .of(new MonitoridKeyEntryBuilder().setMonitorId(Uint32.TWO)
 359                         .setMonitorKey("Test monitor Key").build());
 360         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 361                 argThat(isType(MonitoridKeyEntry.class))))
 362                         .thenReturn(FluentFutures.immediateFluentFuture(optMap));
 363         Optional<MonitorProfile> optProfile = Optional
 364                 .of(getTestMonitorProfile());
 365         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 366                 argThat(isType(MonitorProfile.class))))
 367                         .thenReturn(FluentFutures.immediateFluentFuture(optProfile));
 368         Optional<InterfaceMonitorEntry> optEntry = Optional
 369                 .of(getInterfaceMonitorEntry());
 370         when(readWriteTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 371                 argThat(isType(InterfaceMonitorEntry.class))))
 372                         .thenReturn(FluentFutures.immediateFluentFuture(optEntry));
 373         RpcResult<MonitorStopOutput> result = alivenessMonitor.monitorStop(input).get();
 374         verify(idManager).releaseId(any(ReleaseIdInput.class));
 375         verify(writeTx, times(3)).delete(eq(LogicalDatastoreType.OPERATIONAL),
 376                 any(InstanceIdentifier.class));
 377         assertTrue("Monitor stop rpc result", result.isSuccessful());
 378     }
 379
 380     @Test
 381     public void testMonitorProfileDelete()
 382             throws InterruptedException, ExecutionException {
 383         MonitorProfileDeleteInput input = new MonitorProfileDeleteInputBuilder()
 384                 .setProfileId(Uint32.ONE).build();
 385         Optional<MonitorProfile> optProfile = Optional
 386                 .of(getTestMonitorProfile());
 387         when(readWriteTx.read(eq(LogicalDatastoreType.OPERATIONAL),
 388                 argThat(isType(MonitorProfile.class))))
 389                         .thenReturn(FluentFutures.immediateFluentFuture(optProfile));
 390         RpcResult<MonitorProfileDeleteOutput> result = alivenessMonitor.monitorProfileDelete(input)
 391                 .get();
 392         verify(idManager).releaseId(any(ReleaseIdInput.class));
 393         verify(readWriteTx).delete(eq(LogicalDatastoreType.OPERATIONAL),
 394                 Matchers.<InstanceIdentifier<MonitorProfile>>any());
 395         assertTrue("Monitor profile delete result", result.isSuccessful());
 396     }
 397
 398     @SuppressWarnings("unchecked")
 399     private Uint32 createProfile()
 400             throws InterruptedException, ExecutionException {
 401         MonitorProfileCreateInput input = new MonitorProfileCreateInputBuilder()
 402                 .setProfile(new ProfileBuilder().setFailureThreshold(Uint32.TEN)
 403                         .setMonitorInterval(Uint32.valueOf(10000)).setMonitorWindow(Uint32.TEN)
 404                         .setProtocolType(MonitorProtocolType.Arp).build())
 405                 .build();
 406         doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
 407                 .when(readWriteTx).read(eq(LogicalDatastoreType.OPERATIONAL),
 408                         any(InstanceIdentifier.class));
 409         doReturn(CommitInfo.emptyFluentFuture()).when(readWriteTx).commit();
 410         RpcResult<MonitorProfileCreateOutput> output = alivenessMonitor
 411                 .monitorProfileCreate(input).get();
 412         return output.getResult().getProfileId();
 413     }
 414
 415     private MonitorProfile getTestMonitorProfile() {
 416         return new MonitorProfileBuilder().setId(Uint32.MAX_VALUE).setFailureThreshold(Uint32.TEN)
 417                 .setMonitorInterval(Uint32.valueOf(10000)).setMonitorWindow(Uint32.TEN)
 418                 .setProtocolType(MonitorProtocolType.Arp).build();
 419     }
 420
 421     private InterfaceMonitorEntry getInterfaceMonitorEntry() {
 422         return new InterfaceMonitorEntryBuilder()
 423                 .setInterfaceName("test-interface")
 424                 .setMonitorIds(Arrays.asList(Uint32.ONE, Uint32.TWO)).build();
 425     }
 426
 427     private Interface getInterface(String ipAddress) {
 428         return new InterfaceBuilder()
 429                 .setInterfaceIp(IpAddressBuilder.getDefaultInstance(ipAddress))
 430                 .build();
 431     }
 432
 433     private Interface getInterface(String interfaceName, String ipAddress) {
 434         return new InterfaceBuilder()
 435                 .setInterfaceIp(IpAddressBuilder.getDefaultInstance(ipAddress))
 436                 .setInterfaceName(interfaceName).build();
 437     }
 438 }