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.doReturn;
  12
  13 import com.google.common.base.Optional;
  14 import java.net.URI;
  15 import java.util.ArrayList;
  16 import java.util.Collections;
  17 import java.util.Date;
  18 import java.util.HashSet;
  19 import java.util.List;
  20 import java.util.Set;
  21 import java.util.concurrent.atomic.AtomicInteger;
  22 import org.junit.Assert;
  23 import org.junit.Before;
  24 import org.junit.BeforeClass;
  25 import org.junit.Test;
  26 import org.mockito.Mock;
  27 import org.mockito.MockitoAnnotations;
  28 import org.opendaylight.controller.config.util.capability.BasicCapability;
  29 import org.opendaylight.controller.config.util.capability.Capability;
  30 import org.opendaylight.controller.config.util.capability.YangModuleCapability;
  31 import org.opendaylight.netconf.api.monitoring.NetconfManagementSession;
  32 import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
  33 import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
  34 import org.opendaylight.netconf.notifications.BaseNotificationPublisherRegistration;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.CapabilitiesBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.SessionBuilder;
  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.SimpleDateFormatUtil;
  44 import org.opendaylight.yangtools.yang.model.api.Module;
  45
  46 public class NetconfMonitoringServiceImplTest {
  47
  48     private static final String TEST_MODULE_CONTENT = "content";
  49     private static final String TEST_MODULE_CONTENT2 = "content2";
  50     private static final String TEST_MODULE_REV = "1970-01-01";
  51     private static final String TEST_MODULE_REV2 = "1970-01-02";
  52     private static final  Uri TEST_MODULE_NAMESPACE = new Uri("testModuleNamespace");
  53     private static final String TEST_MODULE_NAME = "testModule";
  54     private static Date TEST_MODULE_DATE;
  55     private static Date TEST_MODULE_DATE2;
  56
  57     private YangModuleCapability moduleCapability1;
  58     private YangModuleCapability moduleCapability2;
  59
  60     private final Set<Capability> CAPABILITIES = new HashSet<>();
  61
  62     private NetconfMonitoringServiceImpl monitoringService;
  63     @Mock
  64     private Module moduleMock;
  65     @Mock
  66     private Module moduleMock2;
  67     @Mock
  68     private NetconfOperationServiceFactory operationServiceFactoryMock;
  69     @Mock
  70     private NetconfManagementSession sessionMock;
  71
  72     @BeforeClass
  73     public static void suiteSetUp() throws Exception {
  74         TEST_MODULE_DATE = SimpleDateFormatUtil.getRevisionFormat().parse(TEST_MODULE_REV);
  75         TEST_MODULE_DATE2= SimpleDateFormatUtil.getRevisionFormat().parse(TEST_MODULE_REV2);
  76     }
  77
  78     @Before
  79     public void setUp() throws Exception {
  80         MockitoAnnotations.initMocks(this);
  81         CAPABILITIES.add(new BasicCapability("urn:ietf:params:netconf:base:1.0"));
  82         CAPABILITIES.add(new BasicCapability("urn:ietf:params:netconf:base:1.1"));
  83         CAPABILITIES.add(new BasicCapability("urn:ietf:params:xml:ns:yang:ietf-inet-types?module=ietf-inet-types&amp;revision=2010-09-24"));
  84         doReturn(new URI(TEST_MODULE_NAMESPACE.getValue())).when(moduleMock).getNamespace();
  85         doReturn(TEST_MODULE_NAME).when(moduleMock).getName();
  86         doReturn(TEST_MODULE_DATE).when(moduleMock).getRevision();
  87         moduleCapability1 = new YangModuleCapability(moduleMock, TEST_MODULE_CONTENT);
  88
  89         CAPABILITIES.add(moduleCapability1);
  90
  91         doReturn(new URI(TEST_MODULE_NAMESPACE.getValue())).when(moduleMock2).getNamespace();
  92         doReturn(TEST_MODULE_NAME).when(moduleMock2).getName();
  93         doReturn(TEST_MODULE_DATE2).when(moduleMock2).getRevision();
  94         moduleCapability2 = new YangModuleCapability(moduleMock2, TEST_MODULE_CONTENT2);
  95
  96         doReturn(CAPABILITIES).when(operationServiceFactoryMock).getCapabilities();
  97         doReturn(null).when(operationServiceFactoryMock).registerCapabilityListener(any(NetconfMonitoringServiceImpl.class));
  98
  99         monitoringService = new NetconfMonitoringServiceImpl(operationServiceFactoryMock);
 100         monitoringService.onCapabilitiesChanged(CAPABILITIES, Collections.emptySet());
 101
 102         doReturn(new SessionBuilder().build()).when(sessionMock).toManagementSession();
 103     }
 104
 105     @Test
 106     public void testListeners() throws Exception {
 107         final AtomicInteger stateChanged = new AtomicInteger(0);
 108         NetconfMonitoringService.MonitoringListener listener = getMonitoringListener(stateChanged);
 109         monitoringService.registerListener(listener);
 110         Assert.assertEquals(1, stateChanged.get());
 111         monitoringService.onSessionUp(sessionMock);
 112         Assert.assertEquals(2, stateChanged.get());
 113         HashSet<Capability> added = new HashSet<>();
 114         added.add(new BasicCapability("toAdd"));
 115         monitoringService.onCapabilitiesChanged(added, new HashSet<Capability>());
 116         Assert.assertEquals(3, stateChanged.get());
 117         monitoringService.onSessionDown(sessionMock);
 118         Assert.assertEquals(4, stateChanged.get());
 119     }
 120
 121     @Test
 122     public void testGetSchemas() throws Exception {
 123         Schemas schemas = monitoringService.getSchemas();
 124         Schema schema = schemas.getSchema().get(0);
 125         Assert.assertEquals(TEST_MODULE_NAMESPACE, schema.getNamespace());
 126         Assert.assertEquals(TEST_MODULE_NAME, schema.getIdentifier());
 127         Assert.assertEquals(TEST_MODULE_REV, schema.getVersion());
 128
 129     }
 130
 131     @Test
 132     public void testGetSchemaForCapability() throws Exception {
 133         //test multiple revisions of the same capability
 134         monitoringService.onCapabilitiesChanged(Collections.singleton(moduleCapability2), Collections.emptySet());
 135         final String schema = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.of(TEST_MODULE_REV));
 136         Assert.assertEquals(TEST_MODULE_CONTENT, schema);
 137         final String schema2 = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.of(TEST_MODULE_REV2));
 138         Assert.assertEquals(TEST_MODULE_CONTENT2, schema2);
 139         //remove one revision
 140         monitoringService.onCapabilitiesChanged(Collections.emptySet(), Collections.singleton(moduleCapability1));
 141         //only one revision present
 142         final String schema3 = monitoringService.getSchemaForCapability(TEST_MODULE_NAME, Optional.absent());
 143         Assert.assertEquals(TEST_MODULE_CONTENT2, schema3);
 144     }
 145
 146     @Test
 147     public void testGetCapabilities() throws Exception {
 148         Capabilities actual = monitoringService.getCapabilities();
 149         List<Uri> exp = new ArrayList<>();
 150         for (Capability capability : CAPABILITIES) {
 151             exp.add(new Uri(capability.getCapabilityUri()));
 152         }
 153         exp.add(0, new Uri("urn:ietf:params:netconf:capability:candidate:1.0"));
 154         Capabilities expected = new CapabilitiesBuilder().setCapability(exp).build();
 155         Assert.assertEquals(new HashSet<>(expected.getCapability()), new HashSet<>(actual.getCapability()));
 156     }
 157
 158     @Test
 159     public void testClose() throws Exception {
 160         monitoringService.onSessionUp(sessionMock);
 161         Assert.assertFalse(monitoringService.getSessions().getSession().isEmpty());
 162         Assert.assertFalse(monitoringService.getCapabilities().getCapability().isEmpty());
 163         monitoringService.close();
 164         Assert.assertTrue(monitoringService.getSessions().getSession().isEmpty());
 165         Assert.assertTrue(monitoringService.getCapabilities().getCapability().isEmpty());
 166     }
 167
 168     @Test
 169     public void testOnCapabilitiesChanged() throws Exception {
 170         final List<String> actualCapabilities = new ArrayList<>();
 171         monitoringService.registerListener(new NetconfMonitoringService.MonitoringListener() {
 172             @Override
 173             public void onStateChanged(NetconfState state) {
 174                 List<Uri> capability = state.getCapabilities().getCapability();
 175                 for (Uri uri : capability) {
 176                     actualCapabilities.add(uri.getValue());
 177                 }
 178             }
 179         });
 180         HashSet<Capability> testCaps = new HashSet<>();
 181         String capUri = "test";
 182         testCaps.add(new BasicCapability(capUri));
 183         monitoringService.onCapabilitiesChanged(testCaps, new HashSet<Capability>());
 184         Assert.assertTrue(actualCapabilities.contains(capUri));
 185         actualCapabilities.clear();
 186         monitoringService.onCapabilitiesChanged(new HashSet<Capability>(), testCaps);
 187         Assert.assertFalse(actualCapabilities.contains(capUri));
 188     }
 189
 190     @Test
 191     public void testonCapabilitiesChanged() throws Exception {
 192         final String toAdd = "toAdd";
 193         final String toRemove = "toRemove";
 194         monitoringService.setNotificationPublisher(new BaseNotificationPublisherRegistration() {
 195             @Override
 196             public void onCapabilityChanged(NetconfCapabilityChange capabilityChange) {
 197                 Assert.assertEquals(1, capabilityChange.getAddedCapability().size());
 198
 199                 Assert.assertEquals(toAdd, capabilityChange.getAddedCapability().get(0).getValue());
 200                 Assert.assertEquals(1, capabilityChange.getDeletedCapability().size());
 201                 Assert.assertEquals(toRemove, capabilityChange.getDeletedCapability().get(0).getValue());
 202             }
 203
 204             @Override
 205             public void close() {
 206
 207             }
 208         });
 209         Set<Capability> removed = new HashSet<>();
 210         removed.add(new BasicCapability(toRemove));
 211         Set<Capability> added = new HashSet<>();
 212         added.add(new BasicCapability(toAdd));
 213         monitoringService.onCapabilitiesChanged(added, removed);
 214     }
 215
 216     private NetconfMonitoringService.MonitoringListener getMonitoringListener(final AtomicInteger stateChanged) {
 217         return new NetconfMonitoringService.MonitoringListener() {
 218             @Override
 219             public void onStateChanged(NetconfState state) {
 220                 stateChanged.incrementAndGet();
 221             }
 222         };
 223     }
 224
 225 }