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