import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyCollectionOf;
import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.after;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.SettableFuture;
import java.io.IOException;
-import java.io.InputStream;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
-import org.opendaylight.yangtools.yang.parser.util.ASTSchemaSource;
+import org.opendaylight.yangtools.yang.parser.rfc7950.repo.ASTSchemaSource;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.xml.sax.SAXException;
public static final String TEST_MODULE = "test-module";
public static final String TEST_REVISION = "2013-07-22";
public static final SourceIdentifier TEST_SID =
- RevisionSourceIdentifier.create(TEST_MODULE, Optional.of(TEST_REVISION));
+ RevisionSourceIdentifier.create(TEST_MODULE, Revision.of(TEST_REVISION));
public static final String TEST_CAPABILITY =
TEST_NAMESPACE + "?module=" + TEST_MODULE + "&revision=" + TEST_REVISION;
public static final SourceIdentifier TEST_SID2 =
- RevisionSourceIdentifier.create(TEST_MODULE + "2", Optional.of(TEST_REVISION));
+ RevisionSourceIdentifier.create(TEST_MODULE + "2", Revision.of(TEST_REVISION));
public static final String TEST_CAPABILITY2 =
TEST_NAMESPACE + "?module=" + TEST_MODULE + "2" + "&revision=" + TEST_REVISION;
new SchemaResolutionException("fail first", TEST_SID, new Throwable("YangTools parser fail"));
doAnswer(invocation -> {
if (((Collection<?>) invocation.getArguments()[0]).size() == 2) {
- return Futures.immediateFailedCheckedFuture(schemaResolutionException);
+ return Futures.immediateFailedFuture(schemaResolutionException);
} else {
- return Futures.immediateCheckedFuture(schema);
+ return Futures.immediateFuture(schema);
}
}).when(schemaFactory).createSchemaContext(anyCollectionOf(SourceIdentifier.class));
final SchemaResolutionException schemaResolutionException
= new SchemaResolutionException("fail first",
Collections.<SourceIdentifier>emptyList(), HashMultimap.<SourceIdentifier, ModuleImport>create());
- doReturn(Futures.immediateFailedCheckedFuture(
- schemaResolutionException))
+ doReturn(Futures.immediateFailedFuture(schemaResolutionException))
.when(schemaFactory).createSchemaContext(anyCollectionOf(SourceIdentifier.class));
final NetconfDevice.SchemaResourcesDTO schemaResourcesDTO = new NetconfDevice
// Make fallback attempt to fail due to empty resolved sources
final MissingSchemaSourceException schemaResolutionException =
new MissingSchemaSourceException("fail first", TEST_SID);
- doReturn(Futures.immediateFailedCheckedFuture(schemaResolutionException))
+ doReturn(Futures.immediateFailedFuture(schemaResolutionException))
.when(schemaRepository).getSchemaSource(eq(TEST_SID), eq(ASTSchemaSource.class));
doAnswer(invocation -> {
if (((Collection<?>) invocation.getArguments()[0]).size() == 2) {
- return Futures.immediateFailedCheckedFuture(schemaResolutionException);
+ return Futures.immediateFailedFuture(schemaResolutionException);
} else {
- return Futures.immediateCheckedFuture(schema);
+ return Futures.immediateFuture(schema);
}
}).when(schemaFactory).createSchemaContext(anyCollectionOf(SourceIdentifier.class));
private static SchemaRepository getSchemaRepository() {
final SchemaRepository mock = mock(SchemaRepository.class);
final SchemaSourceRepresentation mockRep = mock(SchemaSourceRepresentation.class);
- doReturn(Futures.immediateCheckedFuture(mockRep))
+ doReturn(Futures.immediateFuture(mockRep))
.when(mock).getSchemaSource(any(SourceIdentifier.class), eq(ASTSchemaSource.class));
return mock;
}
public void testNotificationBeforeSchema() throws Exception {
final RemoteDeviceHandler<NetconfSessionPreferences> facade = getFacade();
final NetconfDeviceCommunicator listener = getListener();
-
- final NetconfDevice.SchemaResourcesDTO schemaResourcesDTO = new NetconfDevice.SchemaResourcesDTO(
- getSchemaRegistry(), getSchemaRepository(), getSchemaFactory(), STATE_SCHEMAS_RESOLVER);
+ final SchemaContextFactory schemaContextProviderFactory = mock(SchemaContextFactory.class);
+ final SettableFuture<SchemaContext> schemaFuture = SettableFuture.create();
+ doReturn(schemaFuture).when(schemaContextProviderFactory).createSchemaContext(any(Collection.class));
+ final NetconfDevice.SchemaResourcesDTO schemaResourcesDTO =
+ new NetconfDevice.SchemaResourcesDTO(getSchemaRegistry(), getSchemaRepository(),
+ schemaContextProviderFactory, STATE_SCHEMAS_RESOLVER);
final NetconfDevice device = new NetconfDeviceBuilder()
.setReconnectOnSchemasChange(true)
.setSchemaResourcesDTO(schemaResourcesDTO)
.setSalFacade(facade)
.build();
- device.onNotification(NOTIFICATION);
- device.onNotification(NOTIFICATION);
-
- verify(facade, times(0)).onNotification(any(DOMNotification.class));
-
final NetconfSessionPreferences sessionCaps = getSessionCaps(true,
Lists.newArrayList(TEST_CAPABILITY));
+ device.onRemoteSessionUp(sessionCaps, listener);
- final DOMRpcService deviceRpc = mock(DOMRpcService.class);
-
- device.handleSalInitializationSuccess(
- NetconfToNotificationTest.getNotificationSchemaContext(getClass(), false), sessionCaps, deviceRpc);
+ device.onNotification(NOTIFICATION);
+ device.onNotification(NOTIFICATION);
+ verify(facade, times(0)).onNotification(any(DOMNotification.class));
+ verify(facade, times(0)).onNotification(any(DOMNotification.class));
+ schemaFuture.set(NetconfToNotificationTest.getNotificationSchemaContext(getClass(), false));
verify(facade, timeout(10000).times(2)).onNotification(any(DOMNotification.class));
device.onNotification(NOTIFICATION);
any(SchemaContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class));
}
+ @Test
+ public void testNetconfDeviceDisconnectListenerCallCancellation() throws Exception {
+ final RemoteDeviceHandler<NetconfSessionPreferences> facade = getFacade();
+ final NetconfDeviceCommunicator listener = getListener();
+ final SchemaContextFactory schemaContextProviderFactory = mock(SchemaContextFactory.class);
+ final SettableFuture<SchemaContext> schemaFuture = SettableFuture.create();
+ doReturn(schemaFuture).when(schemaContextProviderFactory).createSchemaContext(any(Collection.class));
+ final NetconfDevice.SchemaResourcesDTO schemaResourcesDTO
+ = new NetconfDevice.SchemaResourcesDTO(getSchemaRegistry(), getSchemaRepository(),
+ schemaContextProviderFactory, STATE_SCHEMAS_RESOLVER);
+ final NetconfDevice device = new NetconfDeviceBuilder()
+ .setReconnectOnSchemasChange(true)
+ .setSchemaResourcesDTO(schemaResourcesDTO)
+ .setGlobalProcessingExecutor(getExecutor())
+ .setId(getId())
+ .setSalFacade(facade)
+ .build();
+ final NetconfSessionPreferences sessionCaps = getSessionCaps(true,
+ Lists.newArrayList(TEST_NAMESPACE + "?module=" + TEST_MODULE + "&revision=" + TEST_REVISION));
+ //session up, start schema resolution
+ device.onRemoteSessionUp(sessionCaps, listener);
+ //session closed
+ device.onRemoteSessionDown();
+ verify(facade, timeout(5000)).onDeviceDisconnected();
+ //complete schema setup
+ schemaFuture.set(getSchema());
+ //facade.onDeviceDisconnected() was called, so facade.onDeviceConnected() shouldn't be called anymore
+ verify(facade, after(1000).never()).onDeviceConnected(any(), any(), any());
+ }
+
@Test
public void testNetconfDeviceAvailableCapabilitiesBuilding() throws Exception {
final RemoteDeviceHandler<NetconfSessionPreferences> facade = getFacade();
.setId(getId())
.setSalFacade(facade)
.build();
- NetconfDevice netconfSpy = Mockito.spy(device);
+ final NetconfDevice netconfSpy = Mockito.spy(device);
final NetconfSessionPreferences sessionCaps = getSessionCaps(true,
Lists.newArrayList(TEST_NAMESPACE + "?module=" + TEST_MODULE + "&revision=" + TEST_REVISION));
- Map<QName, AvailableCapability.CapabilityOrigin> moduleBasedCaps = new HashMap<>();
+ final Map<QName, AvailableCapability.CapabilityOrigin> moduleBasedCaps = new HashMap<>();
moduleBasedCaps.putAll(sessionCaps.getModuleBasedCapsOrigin());
moduleBasedCaps
.put(QName.create("(test:qname:side:loading)test"), AvailableCapability.CapabilityOrigin.UserDefined);
netconfSpy.onRemoteSessionUp(sessionCaps.replaceModuleCaps(moduleBasedCaps), listener);
- ArgumentCaptor argument = ArgumentCaptor.forClass(NetconfSessionPreferences.class);
- verify(netconfSpy, timeout(5000)).handleSalInitializationSuccess(
- any(SchemaContext.class), (NetconfSessionPreferences) argument.capture(), any(DOMRpcService.class));
- NetconfDeviceCapabilities netconfDeviceCaps =
- ((NetconfSessionPreferences) argument.getValue()).getNetconfDeviceCapabilities();
+ final ArgumentCaptor<NetconfSessionPreferences> argument =
+ ArgumentCaptor.forClass(NetconfSessionPreferences.class);
+ verify(facade, timeout(5000))
+ .onDeviceConnected(any(SchemaContext.class), argument.capture(), any(DOMRpcService.class));
+ final NetconfDeviceCapabilities netconfDeviceCaps = argument.getValue().getNetconfDeviceCapabilities();
netconfDeviceCaps.getResolvedCapabilities()
.forEach(entry -> assertEquals("Builded 'AvailableCapability' schemas should match input capabilities.",
private static SchemaContextFactory getSchemaFactory() throws Exception {
final SchemaContextFactory schemaFactory = mockClass(SchemaContextFactory.class);
- doReturn(Futures.immediateCheckedFuture(getSchema()))
+ doReturn(Futures.immediateFuture(getSchema()))
.when(schemaFactory).createSchemaContext(any(Collection.class));
return schemaFactory;
}
- public static SchemaContext getSchema() throws Exception {
- final List<InputStream> modelsToParse = Lists.newArrayList(
- NetconfDeviceTest.class.getResourceAsStream("/schemas/test-module.yang")
- );
- return YangParserTestUtils.parseYangStreams(modelsToParse);
+ public static SchemaContext getSchema() {
+ return YangParserTestUtils.parseYangResource("/schemas/test-module.yang");
}
private static RemoteDeviceHandler<NetconfSessionPreferences> getFacade() throws Exception {
Code Review / netconf.git / blobdiff