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