2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.netconf.impl.osgi;
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;
16 import com.google.common.base.Optional;
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;
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;
50 public class NetconfMonitoringServiceImplTest {
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;
61 private YangModuleCapability moduleCapability1;
62 private YangModuleCapability moduleCapability2;
63 private static final Session SESSION = new SessionBuilder()
65 .setSourceHost(new Host("0.0.0.0".toCharArray()))
68 private int capabilitiesSize;
70 private final Set<Capability> CAPABILITIES = new HashSet<>();
73 private Module moduleMock;
75 private Module moduleMock2;
77 private NetconfOperationServiceFactory operationServiceFactoryMock;
79 private NetconfManagementSession sessionMock;
81 private NetconfMonitoringService.MonitoringListener listener;
83 private BaseNotificationPublisherRegistration notificationPublisher;
85 private NetconfMonitoringServiceImpl monitoringService;
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);
94 public void setUp() throws Exception {
95 MockitoAnnotations.initMocks(this);
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);
102 CAPABILITIES.add(moduleCapability1);
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);
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&revision=2010-09-24"));
113 doReturn(CAPABILITIES).when(operationServiceFactoryMock).getCapabilities();
114 doReturn(null).when(operationServiceFactoryMock).registerCapabilityListener(any(NetconfMonitoringServiceImpl.class));
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());
122 doNothing().when(notificationPublisher).onCapabilityChanged(any());
123 doNothing().when(notificationPublisher).onSessionStarted(any());
124 doNothing().when(notificationPublisher).onSessionEnded(any());
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();
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());
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());
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);
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()));
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()));
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());
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);
203 monitoringService.onCapabilitiesChanged(testCaps, Collections.emptySet());
205 monitoringService.onCapabilitiesChanged(Collections.emptySet(), testCaps);
207 verify(listener, times(3)).onCapabilitiesChanged((monitoringListenerCaptor.capture()));
208 verify(notificationPublisher, times(2)).onCapabilityChanged(capabilityChangeCaptor.capture());
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();
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));
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);
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()));
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());
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());