netconf/netconf-impl/src/test/java/org/opendaylight/netconf/impl/osgi/NetconfMonitoringServiceImplTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. 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.netconf.impl.osgi;
   9
  10 import static org.mockito.Matchers.any;
  11 import static org.mockito.Mockito.doNothing;
  12 import static org.mockito.Mockito.doReturn;
  13 import static org.mockito.Mockito.times;
  14 import static org.mockito.Mockito.verify;
  15
  16 import com.google.common.base.Optional;
  17 import java.net.URI;
  18 import java.util.ArrayList;
  19 import java.util.Collections;
  20 import java.util.Date;
  21 import java.util.HashSet;
  22 import java.util.List;
  23 import java.util.Set;
  24 import org.junit.Assert;
  25 import org.junit.Before;
  26 import org.junit.BeforeClass;
  27 import org.junit.Test;
  28 import org.mockito.ArgumentCaptor;
  29 import org.mockito.Mock;
  30 import org.mockito.MockitoAnnotations;
  31 import org.opendaylight.controller.config.util.capability.BasicCapability;
  32 import org.opendaylight.controller.config.util.capability.Capability;
  33 import org.opendaylight.controller.config.util.capability.YangModuleCapability;
  34 import org.opendaylight.netconf.api.monitoring.NetconfManagementSession;
  35 import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
  36 import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
  37 import org.opendaylight.netconf.notifications.BaseNotificationPublisherRegistration;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Host;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.CapabilitiesBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.SessionBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfCapabilityChange;
  47 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
  48 import org.opendaylight.yangtools.yang.model.api.Module;
  49
  50 public class NetconfMonitoringServiceImplTest {
  51
  52     private static final String TEST_MODULE_CONTENT = "content";
  53     private static final String TEST_MODULE_CONTENT2 = "content2";
  54     private static final String TEST_MODULE_REV = "1970-01-01";
  55     private static final String TEST_MODULE_REV2 = "1970-01-02";
  56     private static final  Uri TEST_MODULE_NAMESPACE = new Uri("testModuleNamespace");
  57     private static final String TEST_MODULE_NAME = "testModule";
  58     private static Date TEST_MODULE_DATE;
  59     private static Date TEST_MODULE_DATE2;
  60
  61     private YangModuleCapability moduleCapability1;
  62     private YangModuleCapability moduleCapability2;
  63     private static final Session SESSION = new SessionBuilder()
  64             .setSessionId(1L)
  65             .setSourceHost(new Host("0.0.0.0".toCharArray()))
  66             .setUsername("admin")
  67             .build();
  68     private int capabilitiesSize;
  69
  70     private final Set<Capability> CAPABILITIES = new HashSet<>();
  71
  72     @Mock
  73     private Module moduleMock;
  74     @Mock
  75     private Module moduleMock2;
  76     @Mock
  77     private NetconfOperationServiceFactory operationServiceFactoryMock;
  78     @Mock
  79     private NetconfManagementSession sessionMock;
  80     @Mock
  81     private NetconfMonitoringService.MonitoringListener listener;
  82     @Mock
  83     private BaseNotificationPublisherRegistration notificationPublisher;
  84
  85     private NetconfMonitoringServiceImpl monitoringService;
  86
  87     @BeforeClass
  88     public static void suiteSetUp() throws Exception {
  89         TEST_MODULE_DATE = SimpleDateFormatUtil.getRevisionFormat().parse(TEST_MODULE_REV);
  90         TEST_MODULE_DATE2= SimpleDateFormatUtil.getRevisionFormat().parse(TEST_MODULE_REV2);
  91     }
  92
  93     @Before
  94     public void setUp() throws Exception {
  95         MockitoAnnotations.initMocks(this);
  96
  97         doReturn(new URI(TEST_MODULE_NAMESPACE.getValue())).when(moduleMock).getNamespace();
  98         doReturn(TEST_MODULE_NAME).when(moduleMock).getName();
  99         doReturn(TEST_MODULE_DATE).when(moduleMock).getRevision();
 100         moduleCapability1 = new YangModuleCapability(moduleMock, TEST_MODULE_CONTENT);
 101
 102         CAPABILITIES.add(moduleCapability1);
 103
 104         doReturn(new URI(TEST_MODULE_NAMESPACE.getValue())).when(moduleMock2).getNamespace();
 105         doReturn(TEST_MODULE_NAME).when(moduleMock2).getName();
 106         doReturn(TEST_MODULE_DATE2).when(moduleMock2).getRevision();
 107         moduleCapability2 = new YangModuleCapability(moduleMock2, TEST_MODULE_CONTENT2);
 108
 109         CAPABILITIES.add(new BasicCapability("urn:ietf:params:netconf:base:1.0"));
 110         CAPABILITIES.add(new BasicCapability("urn:ietf:params:netconf:base:1.1"));
 111         CAPABILITIES.add(new BasicCapability("urn:ietf:params:xml:ns:yang:ietf-inet-types?module=ietf-inet-types&amp;revision=2010-09-24"));
 112
 113         doReturn(CAPABILITIES).when(operationServiceFactoryMock).getCapabilities();
 114         doReturn(null).when(operationServiceFactoryMock).registerCapabilityListener(any(NetconfMonitoringServiceImpl.class));
 115
 116         doReturn(SESSION).when(sessionMock).toManagementSession();
 117         doNothing().when(listener).onCapabilitiesChanged(any());
 118         doNothing().when(listener).onSchemasChanged(any());
 119         doNothing().when(listener).onSessionStarted(any());
 120         doNothing().when(listener).onSessionEnded(any());
 121
 122         doNothing().when(notificationPublisher).onCapabilityChanged(any());
 123         doNothing().when(notificationPublisher).onSessionStarted(any());
 124         doNothing().when(notificationPublisher).onSessionEnded(any());
 125
 126         monitoringService = new NetconfMonitoringServiceImpl(operationServiceFactoryMock);
 127         monitoringService.onCapabilitiesChanged(CAPABILITIES, Collections.emptySet());
 128         monitoringService.setNotificationPublisher(notificationPublisher);
 129         monitoringService.registerListener(listener);
 130         capabilitiesSize = monitoringService.getCapabilities().getCapability().size();
 131     }
 132
 133     @Test
 134     public void testListeners() throws Exception {
 135         monitoringService.onSessionUp(sessionMock);
 136         HashSet<Capability> added = new HashSet<>();
 137         added.add(new BasicCapability("toAdd"));
 138         monitoringService.onCapabilitiesChanged(added, Collections.emptySet());
 139         monitoringService.onSessionDown(sessionMock);
 140         verify(listener).onSessionStarted(any());
 141         verify(listener).onSessionEnded(any());
 142         //onCapabilitiesChanged and onSchemasChanged are invoked also after listener registration
 143         verify(listener, times(2)).onCapabilitiesChanged(any());
 144         verify(listener, times(2)).onSchemasChanged(any());
 145     }
 146
 147     @Test
 148     public void testGetSchemas() throws Exception {
 149         Schemas schemas = monitoringService.getSchemas();
 150         Schema schema = schemas.getSchema().get(0);
 151         Assert.assertEquals(TEST_MODULE_NAMESPACE, schema.getNamespace());
 152         Assert.assertEquals(TEST_MODULE_NAME, schema.getIdentifier());
 153         Assert.assertEquals(TEST_MODULE_REV, schema.getVersion());
 154     }
 155
 156     @Test
 157     public void testGetSchemaForCapability() throws Exception {
 158         //test multiple revisions of the same capability
 159         monitoringService.onCapabilitiesChanged(Collections.singleton(moduleCapability2), Collections.emptySet());
 160         final String schema = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.of(TEST_MODULE_REV));
 161         Assert.assertEquals(TEST_MODULE_CONTENT, schema);
 162         final String schema2 = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.of(TEST_MODULE_REV2));
 163         Assert.assertEquals(TEST_MODULE_CONTENT2, schema2);
 164         //remove one revision
 165         monitoringService.onCapabilitiesChanged(Collections.emptySet(), Collections.singleton(moduleCapability1));
 166         //only one revision present
 167         final String schema3 = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.absent());
 168         Assert.assertEquals(TEST_MODULE_CONTENT2, schema3);
 169     }
 170
 171     @Test
 172     public void testGetCapabilities() throws Exception {
 173         Capabilities actual = monitoringService.getCapabilities();
 174         List<Uri> exp = new ArrayList<>();
 175         for (Capability capability : CAPABILITIES) {
 176             exp.add(new Uri(capability.getCapabilityUri()));
 177         }
 178         //candidate is added by monitoring service automatically
 179         exp.add(0, new Uri("urn:ietf:params:netconf:capability:candidate:1.0"));
 180         Capabilities expected = new CapabilitiesBuilder().setCapability(exp).build();
 181         Assert.assertEquals(new HashSet<>(expected.getCapability()), new HashSet<>(actual.getCapability()));
 182     }
 183
 184     @Test
 185     public void testClose() throws Exception {
 186         monitoringService.onSessionUp(sessionMock);
 187         Assert.assertFalse(monitoringService.getSessions().getSession().isEmpty());
 188         Assert.assertFalse(monitoringService.getCapabilities().getCapability().isEmpty());
 189         monitoringService.close();
 190         Assert.assertTrue(monitoringService.getSessions().getSession().isEmpty());
 191         Assert.assertTrue(monitoringService.getCapabilities().getCapability().isEmpty());
 192     }
 193
 194     @Test
 195     public void testOnCapabilitiesChanged() throws Exception {
 196         final String capUri = "test";
 197         final Uri uri = new Uri(capUri);
 198         final HashSet<Capability> testCaps = new HashSet<>();
 199         testCaps.add(new BasicCapability(capUri));
 200         final ArgumentCaptor<NetconfCapabilityChange> capabilityChangeCaptor = ArgumentCaptor.forClass(NetconfCapabilityChange.class);
 201         final ArgumentCaptor<Capabilities> monitoringListenerCaptor = ArgumentCaptor.forClass(Capabilities.class);
 202         //add capability
 203         monitoringService.onCapabilitiesChanged(testCaps, Collections.emptySet());
 204         //remove capability
 205         monitoringService.onCapabilitiesChanged(Collections.emptySet(), testCaps);
 206
 207         verify(listener, times(3)).onCapabilitiesChanged((monitoringListenerCaptor.capture()));
 208         verify(notificationPublisher, times(2)).onCapabilityChanged(capabilityChangeCaptor.capture());
 209
 210         //verify listener calls
 211         final List<Capabilities> listenerValues = monitoringListenerCaptor.getAllValues();
 212         final List<Uri> afterRegisterState = listenerValues.get(0).getCapability();
 213         final List<Uri> afterAddState = listenerValues.get(1).getCapability();
 214         final List<Uri> afterRemoveState = listenerValues.get(2).getCapability();
 215
 216         Assert.assertEquals(capabilitiesSize, afterRegisterState.size());
 217         Assert.assertEquals(capabilitiesSize + 1, afterAddState.size());
 218         Assert.assertEquals(capabilitiesSize, afterRemoveState.size());
 219         Assert.assertFalse(afterRegisterState.contains(uri));
 220         Assert.assertTrue(afterAddState.contains(uri));
 221         Assert.assertFalse(afterRemoveState.contains(uri));
 222
 223         //verify notification publication
 224         final List<NetconfCapabilityChange> publisherValues = capabilityChangeCaptor.getAllValues();
 225         final NetconfCapabilityChange afterAdd = publisherValues.get(0);
 226         final NetconfCapabilityChange afterRemove = publisherValues.get(1);
 227
 228         Assert.assertEquals(Collections.singleton(uri), new HashSet<>(afterAdd.getAddedCapability()));
 229         Assert.assertEquals(Collections.emptySet(), new HashSet<>(afterAdd.getDeletedCapability()));
 230         Assert.assertEquals(Collections.singleton(uri), new HashSet<>(afterRemove.getDeletedCapability()));
 231         Assert.assertEquals(Collections.emptySet(), new HashSet<>(afterRemove.getAddedCapability()));
 232     }
 233
 234     @Test
 235     public void testOnSessionUpAndDown() throws Exception {
 236         monitoringService.onSessionUp(sessionMock);
 237         ArgumentCaptor<Session> sessionUpCaptor = ArgumentCaptor.forClass(Session.class);
 238         verify(listener).onSessionStarted(sessionUpCaptor.capture());
 239         final Session sesionUp = sessionUpCaptor.getValue();
 240         Assert.assertEquals(SESSION.getSessionId(), sesionUp.getSessionId());
 241         Assert.assertEquals(SESSION.getSourceHost(), sesionUp.getSourceHost());
 242         Assert.assertEquals(SESSION.getUsername(), sesionUp.getUsername());
 243
 244         monitoringService.onSessionDown(sessionMock);
 245         ArgumentCaptor<Session> sessionDownCaptor = ArgumentCaptor.forClass(Session.class);
 246         verify(listener).onSessionEnded(sessionDownCaptor.capture());
 247         final Session sessionDown = sessionDownCaptor.getValue();
 248         Assert.assertEquals(SESSION.getSessionId(), sessionDown.getSessionId());
 249         Assert.assertEquals(SESSION.getSourceHost(), sessionDown.getSourceHost());
 250         Assert.assertEquals(SESSION.getUsername(), sessionDown.getUsername());
 251     }
 252 }