apps/callhome-provider/src/test/java/org/opendaylight/netconf/callhome/mount/CallHomeMountDispatcherTest.java

   1 /*
   2  * Copyright (c) 2016 Brocade Communication Systems 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.callhome.mount;
   9
  10 import static org.junit.Assert.assertFalse;
  11 import static org.mockito.ArgumentMatchers.any;
  12 import static org.mockito.ArgumentMatchers.eq;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.mock;
  15 import static org.mockito.Mockito.times;
  16 import static org.mockito.Mockito.verify;
  17
  18 import io.netty.util.concurrent.EventExecutor;
  19 import io.netty.util.concurrent.Future;
  20 import java.net.InetSocketAddress;
  21 import java.net.UnknownHostException;
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.opendaylight.aaa.encrypt.AAAEncryptionService;
  25 import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
  26 import org.opendaylight.controller.config.threadpool.ThreadPool;
  27 import org.opendaylight.mdsal.binding.api.DataBroker;
  28 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
  29 import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
  30 import org.opendaylight.netconf.callhome.protocol.CallHomeChannelActivator;
  31 import org.opendaylight.netconf.callhome.protocol.CallHomeProtocolSessionContext;
  32 import org.opendaylight.netconf.client.NetconfClientSession;
  33 import org.opendaylight.netconf.client.NetconfClientSessionListener;
  34 import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
  35 import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
  36 import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
  37 import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
  38 import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
  39 import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
  40 import org.opendaylight.netconf.nettyutil.ReconnectStrategy;
  41 import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  44
  45 public class CallHomeMountDispatcherTest {
  46     private String topologyId;
  47     private EventExecutor mockExecutor;
  48     private ScheduledThreadPool mockKeepAlive;
  49     private ThreadPool mockProcessingExecutor;
  50     private SchemaResourceManager mockSchemaRepoProvider;
  51
  52     private CallHomeMountDispatcher instance;
  53     private DataBroker mockDataBroker;
  54     private DOMMountPointService mockMount;
  55
  56     private CallHomeMountSessionManager mockSessMgr;
  57     private CallHomeTopology mockTopology;
  58     private CallHomeProtocolSessionContext mockProtoSess;
  59     private AAAEncryptionService mockEncryptionService;
  60     private BaseNetconfSchemas mockBaseSchemas;
  61     private CredentialProvider mockCredentialProvider;
  62     private SslHandlerFactoryProvider mockSslHandlerFactoryProvider;
  63
  64     @Before
  65     public void setup() {
  66         topologyId = "";
  67         mockExecutor = mock(EventExecutor.class);
  68         mockKeepAlive = mock(ScheduledThreadPool.class);
  69         mockProcessingExecutor = mock(ThreadPool.class);
  70         mockSchemaRepoProvider = mock(SchemaResourceManager.class);
  71         mockDataBroker = mock(DataBroker.class);
  72         mockMount = mock(DOMMountPointService.class);
  73         mockSessMgr = mock(CallHomeMountSessionManager.class);
  74         mockTopology = mock(CallHomeTopology.class);
  75         mockProtoSess = mock(CallHomeProtocolSessionContext.class);
  76         mockEncryptionService = mock(AAAEncryptionService.class);
  77         mockBaseSchemas = mock(BaseNetconfSchemas.class);
  78         mockCredentialProvider = mock(CredentialProvider.class);
  79         mockSslHandlerFactoryProvider = mock(SslHandlerFactoryProvider.class);
  80
  81         instance = new CallHomeMountDispatcher(topologyId, mockExecutor, mockKeepAlive,
  82                 mockProcessingExecutor, mockSchemaRepoProvider, mockBaseSchemas, mockDataBroker, mockMount,
  83                 mockEncryptionService, mockCredentialProvider, mockSslHandlerFactoryProvider) {
  84             @Override
  85             CallHomeMountSessionManager sessionManager() {
  86                 return mockSessMgr;
  87             }
  88
  89             @Override
  90             void createTopology() {
  91                 topology = mockTopology;
  92             }
  93         };
  94     }
  95
  96     NetconfClientConfiguration someConfiguration(final InetSocketAddress address) {
  97         // NetconfClientConfiguration has mostly final methods, making it un-mock-able
  98
  99         final NetconfClientConfiguration.NetconfClientProtocol protocol =
 100                 NetconfClientConfiguration.NetconfClientProtocol.SSH;
 101         final NetconfHelloMessageAdditionalHeader additionalHeader = mock(NetconfHelloMessageAdditionalHeader.class);
 102         final NetconfClientSessionListener sessionListener = mock(NetconfClientSessionListener.class);
 103         final ReconnectStrategy reconnectStrategy = mock(ReconnectStrategy.class);
 104         final AuthenticationHandler authHandler = mock(AuthenticationHandler.class);
 105
 106         return NetconfClientConfigurationBuilder.create().withProtocol(protocol).withAddress(address)
 107                 .withConnectionTimeoutMillis(0).withAdditionalHeader(additionalHeader)
 108                 .withSessionListener(sessionListener).withReconnectStrategy(reconnectStrategy)
 109                 .withAuthHandler(authHandler).build();
 110     }
 111
 112     @Test
 113     public void canCreateASessionFromAConfiguration() {
 114         // given
 115         final CallHomeMountSessionContext mockContext = mock(CallHomeMountSessionContext.class);
 116         final InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
 117         doReturn(mockContext).when(mockSessMgr).getByAddress(eq(someAddress));
 118
 119         final NetconfClientConfiguration someCfg = someConfiguration(someAddress);
 120         // when
 121         instance.createClient(someCfg);
 122         // then
 123         verify(mockContext, times(1)).activateNetconfChannel(any(NetconfClientSessionListener.class));
 124     }
 125
 126     @Test
 127     public void noSessionIsCreatedWithoutAContextAvailableForAGivenAddress() {
 128         // given
 129         final InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
 130         final NetconfClientConfiguration someCfg = someConfiguration(someAddress);
 131         // when
 132         final Future<NetconfClientSession> future = instance.createClient(someCfg);
 133         // then
 134         assertFalse(future.isSuccess());
 135     }
 136
 137     @Test
 138     public void nodeIsInsertedIntoTopologyWhenSubsystemIsOpened() throws UnknownHostException {
 139         // given
 140         final NodeId mockNodeId = mock(NodeId.class);
 141         final Node mockNode = mock(Node.class);
 142         final CallHomeMountSessionContext mockDevCtxt = mock(CallHomeMountSessionContext.class);
 143         doReturn(mockNodeId).when(mockDevCtxt).getId();
 144         doReturn(mockNode).when(mockDevCtxt).getConfigNode();
 145         doReturn(mockDevCtxt).when(mockSessMgr).createSession(any(CallHomeProtocolSessionContext.class),
 146                 any(CallHomeChannelActivator.class), any(CallHomeMountSessionContext.CloseCallback.class));
 147         final CallHomeChannelActivator activator = mock(CallHomeChannelActivator.class);
 148         instance.createTopology();
 149         // when
 150         instance.onNetconfSubsystemOpened(mockProtoSess, activator);
 151         // then
 152         verify(instance.topology, times(1)).connectNode(any(Node.class));
 153     }
 154 }