openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/core/PublishingChannelInitializerTest.java

   1 /*
   2  * Copyright (c) 2014 Brocade Communications 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
   9 package org.opendaylight.openflowjava.protocol.impl.core;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.mockito.Matchers.any;
  13 import static org.mockito.Matchers.eq;
  14 import static org.mockito.Mockito.doThrow;
  15 import static org.mockito.Mockito.times;
  16 import static org.mockito.Mockito.verify;
  17 import static org.mockito.Mockito.when;
  18 import io.netty.channel.ChannelHandler;
  19 import io.netty.channel.ChannelPipeline;
  20 import io.netty.channel.group.DefaultChannelGroup;
  21 import io.netty.channel.socket.SocketChannel;
  22 import io.netty.handler.ssl.SslHandler;
  23 import java.net.InetAddress;
  24 import java.net.InetSocketAddress;
  25 import java.net.UnknownHostException;
  26 import javax.net.ssl.SSLEngine;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.mockito.Mock;
  30 import org.mockito.MockitoAnnotations;
  31 import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
  32 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
  33 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
  34 import org.opendaylight.openflowjava.protocol.impl.core.connection.ConnectionAdapterFactory;
  35 import org.opendaylight.openflowjava.protocol.impl.core.connection.ConnectionFacade;
  36 import org.opendaylight.openflowjava.protocol.impl.deserialization.DeserializationFactory;
  37 import org.opendaylight.openflowjava.protocol.impl.serialization.SerializationFactory;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.KeystoreType;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.PathType;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow._switch.connection.provider.impl.rev140328.Tls;
  41
  42 /**
  43  *
  44  * @author james.hall
  45  */
  46 public class PublishingChannelInitializerTest {
  47
  48     @Mock SocketChannel mockSocketCh ;
  49     @Mock ChannelPipeline mockChPipeline ;
  50     @Mock SwitchConnectionHandler mockSwConnHandler ;
  51     @Mock ConnectionAdapterFactory mockConnAdaptorFactory;
  52     @Mock DefaultChannelGroup mockChGrp ;
  53     @Mock ConnectionFacade mockConnFacade ;
  54     @Mock Tls mockTls ;
  55     SSLEngine sslEngine ;
  56
  57     @Mock SerializationFactory mockSerializationFactory ;
  58     @Mock DeserializationFactory mockDeserializationFactory ;
  59
  60     TlsConfiguration tlsConfiguration ;
  61     InetSocketAddress inetSockAddr;
  62     TcpChannelInitializer pubChInitializer  ;
  63
  64     /**
  65      * Sets up test environment
  66      * @throws Exception
  67      */
  68     @Before
  69     public void setUp() throws Exception {
  70         MockitoAnnotations.initMocks(this);
  71         pubChInitializer= new TcpChannelInitializer(mockChGrp, mockConnAdaptorFactory) ;
  72         pubChInitializer.setSerializationFactory(mockSerializationFactory);
  73         pubChInitializer.setDeserializationFactory(mockDeserializationFactory);
  74         pubChInitializer.setSwitchIdleTimeout(1) ;
  75         pubChInitializer.getConnectionIterator() ;
  76         pubChInitializer.setUseBarrier(true);
  77
  78         when( mockChGrp.size()).thenReturn(1) ;
  79         pubChInitializer.setSwitchConnectionHandler( mockSwConnHandler ) ;
  80
  81         inetSockAddr = new InetSocketAddress(InetAddress.getLocalHost(), 8675 ) ;
  82
  83         when(mockConnAdaptorFactory.createConnectionFacade(mockSocketCh, null, true))
  84         .thenReturn(mockConnFacade);
  85         when(mockSocketCh.remoteAddress()).thenReturn(inetSockAddr) ;
  86         when(mockSocketCh.localAddress()).thenReturn(inetSockAddr) ;
  87         when(mockSocketCh.remoteAddress()).thenReturn(inetSockAddr) ;
  88         when(mockSwConnHandler.accept(eq(InetAddress.getLocalHost()))).thenReturn(true) ;
  89         when(mockSocketCh.pipeline()).thenReturn(mockChPipeline) ;
  90
  91         tlsConfiguration = new TlsConfigurationImpl(KeystoreType.JKS, "/selfSignedSwitch", PathType.CLASSPATH,
  92                 KeystoreType.JKS, "/selfSignedController", PathType.CLASSPATH);
  93     }
  94
  95
  96     /**
  97      * Test channel initialization with encryption config set
  98      */
  99     @Test
 100     public void testinitChannelEncryptionSet()  {
 101         pubChInitializer.setTlsConfiguration(tlsConfiguration);
 102         pubChInitializer.initChannel(mockSocketCh) ;
 103
 104         verifyCommonHandlers();
 105         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.SSL_HANDLER.name()),any(SslHandler.class)) ;
 106     }
 107
 108     /**
 109      * Test channel initialization with null encryption config
 110      */
 111     @Test
 112     public void testinitChannelEncryptionSetNullTls()  {
 113         pubChInitializer.setTlsConfiguration(null);
 114         pubChInitializer.initChannel(mockSocketCh) ;
 115
 116         verifyCommonHandlers();
 117         verify(mockChPipeline, times(0)).addLast(eq(PipelineHandlers.SSL_HANDLER.name()),any(SslHandler.class)) ;
 118     }
 119
 120     /**
 121      * Test channel initialization without setting the encryption
 122      */
 123     @Test
 124     public void testinitChannelEncryptionNotSet()  {
 125         // Without encryption, only the common
 126         pubChInitializer.initChannel(mockSocketCh) ;
 127
 128         verifyCommonHandlers();
 129     }
 130
 131     /**
 132      * Test disconnect on new connection rejected
 133      * @throws UnknownHostException
 134      */
 135     @Test
 136     public void testinitChannelNoEncryptionAcceptFails() throws UnknownHostException  {
 137         when(mockSwConnHandler.accept(eq(InetAddress.getLocalHost()))).thenReturn(false) ;
 138         pubChInitializer.initChannel(mockSocketCh) ;
 139
 140         verify(mockSocketCh, times(1)).disconnect();
 141         verify(mockChPipeline, times(0))
 142         .addLast( any(String.class), any(ChannelHandler.class) ) ;
 143     }
 144
 145     /**
 146      * Test channel close on exception during initialization
 147      */
 148     @Test
 149     public void testExceptionThrown() {
 150         doThrow(new IllegalArgumentException()).when(mockSocketCh).pipeline() ;
 151         pubChInitializer.initChannel(mockSocketCh);
 152
 153         verify( mockSocketCh, times(1)).close() ;
 154     }
 155
 156     /**
 157      * All paths should install these six handlers:
 158      */
 159     private void verifyCommonHandlers() {
 160         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.IDLE_HANDLER.name()),any(IdleHandler.class)) ;
 161         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_DECODER.name()),any(OFDecoder.class)) ;
 162         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_ENCODER.name()),any(OFEncoder.class)) ;
 163         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_FRAME_DECODER.name()),any(OFFrameDecoder.class)) ;
 164         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_VERSION_DETECTOR.name()),any(OFVersionDetector.class)) ;
 165         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.DELEGATING_INBOUND_HANDLER.name()),any(DelegatingInboundHandler.class));
 166         assertEquals(1, pubChInitializer.size()) ;
 167     }
 168 }