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

   1 /*
   2  * Copyright (c) 2014 Pantheon Technologies s.r.o. 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.openflowjava.protocol.impl.core.connection;
   9
  10 import com.google.common.collect.Lists;
  11 import com.google.common.util.concurrent.ListenableFuture;
  12 import java.net.InetAddress;
  13 import java.net.UnknownHostException;
  14 import org.junit.Assert;
  15 import org.junit.Test;
  16 import org.mockito.Mock;
  17 import org.mockito.MockitoAnnotations;
  18 import org.opendaylight.openflowjava.protocol.api.connection.OpenflowDiagStatusProvider;
  19 import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
  20 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
  21 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
  22 import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
  23 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralDeserializer;
  24 import org.opendaylight.openflowjava.protocol.api.extensibility.OFGeneralSerializer;
  25 import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
  26 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionDeserializerKey;
  27 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionSerializerKey;
  28 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdDeserializerKey;
  29 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdMeterSubTypeSerializerKey;
  30 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterIdSerializerKey;
  31 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterInstructionDeserializerKey;
  32 import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterInstructionSerializerKey;
  33 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntryDeserializerKey;
  34 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntrySerializerKey;
  35 import org.opendaylight.openflowjava.protocol.api.keys.MessageCodeKey;
  36 import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
  37 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
  38 import org.opendaylight.openflowjava.protocol.impl.core.ServerFacade;
  39 import org.opendaylight.openflowjava.protocol.impl.core.SwitchConnectionProviderImpl;
  40 import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.ExperimenterActionSubType;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.KeystoreType;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.PathType;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.TransportProtocol;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.InPort;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OpenflowBasicClass;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ErrorMessage;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReplyMessage;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandExperimenterCase;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.queue.property.header.QueueProperty;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.table.features.properties.grouping.TableFeatureProperties;
  54 import org.opendaylight.yangtools.yang.common.Uint32;
  55
  56 /**
  57  * Unit tests for SwitchConnectionProviderImpl02.
  58  *
  59  * @author madamjak
  60  * @author michal.polkorab
  61  */
  62 public class SwitchConnectionProviderImpl02Test {
  63     @Mock SwitchConnectionHandler handler;
  64     @Mock OFGeneralSerializer serializer;
  65     @Mock OFGeneralDeserializer deserializer;
  66     @Mock OFDeserializer<ErrorMessage> deserializerError;
  67     @Mock OFDeserializer<ExperimenterDataOfChoice> deserializerExpMsg;
  68     @Mock OFDeserializer<ExperimenterDataOfChoice> deserializerMultipartRplMsg;
  69     @Mock OFDeserializer<QueueProperty> deserializerQueueProperty;
  70     @Mock OFDeserializer<MeterBandExperimenterCase> deserializerMeterBandExpCase;
  71     @Mock OFSerializer<ExperimenterDataOfChoice> serializerExperimenterInput;
  72     @Mock OFSerializer<ExperimenterDataOfChoice> serializerMultipartRequestExpCase;
  73     @Mock OFSerializer<MeterBandExperimenterCase> serializerMeterBandExpCase;
  74     @Mock ConnectionConfigurationImpl config;
  75     @Mock OpenflowDiagStatusProvider openflowPluginDiagStatusProvider;
  76     private static final int CHANNEL_OUTBOUND_QUEUE_SIZE = 1024;
  77     private static final int SWITCH_IDLE_TIMEOUT = 2000;
  78     private TlsConfiguration tlsConfiguration;
  79     private SwitchConnectionProviderImpl provider;
  80
  81     /**
  82      * Creates new {@link SwitchConnectionProvider} instance for each test.
  83      *
  84      * @param protocol communication protocol
  85      */
  86     public void startUp(final TransportProtocol protocol) throws UnknownHostException {
  87         MockitoAnnotations.initMocks(this);
  88         config = null;
  89         if (protocol != null) {
  90             createConfig(protocol);
  91         }
  92         provider = new SwitchConnectionProviderImpl(config,openflowPluginDiagStatusProvider);
  93     }
  94
  95     private void createConfig(final TransportProtocol protocol) throws UnknownHostException {
  96         InetAddress startupAddress = InetAddress.getLocalHost();
  97
  98         tlsConfiguration = null;
  99         if (protocol.equals(TransportProtocol.TLS)) {
 100             tlsConfiguration = new TlsConfigurationImpl(KeystoreType.JKS,
 101                     "/selfSignedSwitch", PathType.CLASSPATH, KeystoreType.JKS,
 102                     "/selfSignedController", PathType.CLASSPATH,
 103                     Lists.newArrayList("TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_128_CBC_SHA256")) ;
 104         }
 105         config = new ConnectionConfigurationImpl(startupAddress, 0, tlsConfiguration, SWITCH_IDLE_TIMEOUT, true, false,
 106                 CHANNEL_OUTBOUND_QUEUE_SIZE);
 107         config.setTransferProtocol(protocol);
 108     }
 109
 110
 111     /**
 112      * Test getServerFacade.
 113      */
 114     @Test
 115     public void testServerFacade() throws UnknownHostException {
 116         startUp(TransportProtocol.TCP);
 117         final ListenableFuture<Boolean> future = provider.startup();
 118         final ServerFacade serverFacade = provider.getServerFacade();
 119         Assert.assertNotNull("Wrong -- getServerFacade return null",serverFacade);
 120     }
 121
 122     /**
 123      * Test shutdown on unconfigured provider.
 124      */
 125     @Test(expected = IllegalStateException.class)
 126     public void testShutdownUnconfigured() throws UnknownHostException {
 127         startUp(TransportProtocol.TCP);
 128         provider.shutdown();
 129     }
 130
 131     /**
 132      * Test unregister by wrong key.
 133      */
 134     @Test
 135     public void testUnregisterWrongKeys() throws UnknownHostException {
 136         startUp(TransportProtocol.TCP);
 137         final ExperimenterInstructionSerializerKey testSerKey
 138             = new ExperimenterInstructionSerializerKey(EncodeConstants.OF_VERSION_1_0, 42L);
 139         Assert.assertFalse("Wrong -- unregisterSerializer",provider.unregisterSerializer(testSerKey));
 140         final ExperimenterInstructionDeserializerKey tesDeserKey
 141             = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF_VERSION_1_0, 24L);
 142         Assert.assertFalse("Wrong -- unregisterDeserializer",provider.unregisterDeserializer(tesDeserKey));
 143     }
 144
 145     /**
 146      * Test register and unregister method.
 147      */
 148     @Test
 149     public void testUnregisterExistingKeys() throws UnknownHostException {
 150         startUp(TransportProtocol.TCP);
 151         // -- registerActionSerializer
 152         final ExperimenterActionSerializerKey key1
 153             = new ExperimenterActionSerializerKey(EncodeConstants.OF_VERSION_1_0, Uint32.valueOf(42),
 154                 TestSubType.class);
 155         provider.registerActionSerializer(key1, serializer);
 156         Assert.assertTrue("Wrong -- unregister ActionSerializer", provider.unregisterSerializer(key1));
 157         Assert.assertFalse("Wrong -- unregister ActionSerializer by not existing key",
 158                 provider.unregisterSerializer(key1));
 159         // -- registerActionDeserializer
 160         final ExperimenterActionDeserializerKey key2
 161             = new ExperimenterActionDeserializerKey(EncodeConstants.OF_VERSION_1_0, 42L);
 162         provider.registerActionDeserializer(key2, deserializer);
 163         Assert.assertTrue("Wrong -- unregister ActionDeserializer", provider.unregisterDeserializer(key2));
 164         Assert.assertFalse("Wrong -- unregister ActionDeserializer by not existing key",
 165                 provider.unregisterDeserializer(key2));
 166         // -- registerInstructionSerializer
 167         final ExperimenterInstructionSerializerKey key3
 168             = new ExperimenterInstructionSerializerKey(EncodeConstants.OF_VERSION_1_0, 42L);
 169         provider.registerInstructionSerializer(key3, serializer);
 170         Assert.assertTrue("Wrong -- unregister InstructionSerializer", provider.unregisterSerializer(key3));
 171         Assert.assertFalse("Wrong -- unregister InstructionSerializer by not existing key",
 172                 provider.unregisterSerializer(key3));
 173         // -- registerInstructionDeserializer
 174         final ExperimenterInstructionDeserializerKey key4
 175             = new ExperimenterInstructionDeserializerKey(EncodeConstants.OF_VERSION_1_0, 42L);
 176         provider.registerInstructionDeserializer(key4, deserializer);
 177         Assert.assertTrue("Wrong -- unregister InstructionDeserializer", provider.unregisterDeserializer(key4));
 178         Assert.assertFalse("Wrong -- unregister InstructionDeserializer by not existing key",
 179                 provider.unregisterDeserializer(key4));
 180         // -- registerMatchEntryDeserializer
 181         final MatchEntryDeserializerKey key5
 182             = new MatchEntryDeserializerKey(EncodeConstants.OF_VERSION_1_0, 0x8000, 42);
 183         provider.registerMatchEntryDeserializer(key5, deserializer);
 184         Assert.assertTrue("Wrong -- unregister MatchEntryDeserializer", provider.unregisterDeserializer(key5));
 185         Assert.assertFalse("Wrong -- unregister MatchEntryDeserializer by not existing key",
 186                 provider.unregisterDeserializer(key5));
 187         // -- registerErrorDeserializer
 188         final ExperimenterIdDeserializerKey key6 = new ExperimenterIdDeserializerKey(EncodeConstants.OF_VERSION_1_0,
 189                 Uint32.valueOf(42), ErrorMessage.class);
 190         provider.registerErrorDeserializer(key6, deserializerError);
 191         Assert.assertTrue("Wrong -- unregister ErrorDeserializer", provider.unregisterDeserializer(key6));
 192         Assert.assertFalse("Wrong -- unregister ErrorDeserializer by not existing key",
 193                 provider.unregisterDeserializer(key6));
 194         // -- registerExperimenterMessageDeserializer
 195         final ExperimenterIdDeserializerKey key7 = new ExperimenterIdDeserializerKey(EncodeConstants.OF_VERSION_1_0,
 196                 Uint32.valueOf(42), ExperimenterMessage.class);
 197         provider.registerExperimenterMessageDeserializer(key7, deserializerExpMsg);
 198         Assert.assertTrue("Wrong -- unregister ExperimenterMessageDeserializer", provider.unregisterDeserializer(key7));
 199         Assert.assertFalse("Wrong -- unregister ExperimenterMessageDeserializer by not existing key",
 200                 provider.unregisterDeserializer(key7));
 201         // -- registerMultipartReplyMessageDeserializer
 202         final ExperimenterIdDeserializerKey key8 = new ExperimenterIdDeserializerKey(EncodeConstants.OF_VERSION_1_0,
 203                 Uint32.valueOf(42), MultipartReplyMessage.class);
 204         provider.registerMultipartReplyMessageDeserializer(key8, deserializerMultipartRplMsg);
 205         Assert.assertTrue("Wrong -- unregister MultipartReplyMessageDeserializer",
 206                 provider.unregisterDeserializer(key8));
 207         Assert.assertFalse("Wrong -- unregister MultipartReplyMessageDeserializer by not existing key",
 208                 provider.unregisterDeserializer(key8));
 209         // -- registerMultipartReplyTFDeserializer
 210         final ExperimenterIdDeserializerKey key9 = new ExperimenterIdDeserializerKey(EncodeConstants.OF_VERSION_1_0,
 211                 Uint32.valueOf(42), MultipartReplyMessage.class);
 212         provider.registerMultipartReplyTFDeserializer(key9, deserializer);
 213         Assert.assertTrue("Wrong -- unregister MultipartReplyTFDeserializer", provider.unregisterDeserializer(key9));
 214         Assert.assertFalse("Wrong -- unregister MultipartReplyTFDeserializer by non existing key",
 215                 provider.unregisterDeserializer(key9));
 216         // -- registerQueuePropertyDeserializer
 217         final ExperimenterIdDeserializerKey key10 = new ExperimenterIdDeserializerKey(EncodeConstants.OF_VERSION_1_0,
 218                 Uint32.valueOf(42), QueueProperty.class);
 219         provider.registerQueuePropertyDeserializer(key10, deserializerQueueProperty);
 220         Assert.assertTrue("Wrong -- unregister QueuePropertyDeserializer", provider.unregisterDeserializer(key10));
 221         Assert.assertFalse("Wrong -- unregister QueuePropertyDeserializer by not existing key",
 222                 provider.unregisterDeserializer(key10));
 223         // -- registerMeterBandDeserializer
 224         final ExperimenterIdDeserializerKey key11 = new ExperimenterIdDeserializerKey(EncodeConstants.OF_VERSION_1_0,
 225                 Uint32.valueOf(42), MeterBandExperimenterCase.class);
 226         provider.registerMeterBandDeserializer(key11, deserializerMeterBandExpCase);
 227         Assert.assertTrue("Wrong -- unregister MeterBandDeserializer", provider.unregisterDeserializer(key11));
 228         Assert.assertFalse("Wrong -- unregister MeterBandDeserializer by not existing key",
 229                 provider.unregisterDeserializer(key11));
 230         // -- registerExperimenterMessageSerializer
 231         ExperimenterIdSerializerKey<ExperimenterDataOfChoice> key12
 232                 = new ExperimenterIdSerializerKey<>(EncodeConstants.OF_VERSION_1_0, Uint32.valueOf(42),
 233                         ExperimenterDataOfChoice.class);
 234         provider.registerExperimenterMessageSerializer(key12, serializerExperimenterInput);
 235         Assert.assertTrue("Wrong -- unregister ExperimenterMessageSerializer", provider.unregisterSerializer(key12));
 236         Assert.assertFalse("Wrong -- unregister ExperimenterMessageSerializer by not existing key",
 237                 provider.unregisterSerializer(key12));
 238         //registerMultipartRequestSerializer
 239         ExperimenterIdSerializerKey<ExperimenterDataOfChoice> key13
 240                 = new ExperimenterIdSerializerKey<>(EncodeConstants.OF_VERSION_1_0, Uint32.valueOf(42),
 241                         ExperimenterDataOfChoice.class);
 242         provider.registerMultipartRequestSerializer(key13, serializerMultipartRequestExpCase);
 243         Assert.assertTrue("Wrong -- unregister MultipartRequestSerializer", provider.unregisterSerializer(key13));
 244         Assert.assertFalse("Wrong -- unregister MultipartRequestSerializer by not existing key",
 245                 provider.unregisterSerializer(key13));
 246         // -- registerMultipartRequestTFSerializer
 247         final ExperimenterIdSerializerKey<TableFeatureProperties> key14
 248             = new ExperimenterIdSerializerKey<>(EncodeConstants.OF_VERSION_1_0, Uint32.valueOf(42),
 249                     TableFeatureProperties.class);
 250         provider.registerMultipartRequestTFSerializer(key14, serializer);
 251         Assert.assertTrue("Wrong -- unregister MultipartRequestTFSerializer", provider.unregisterSerializer(key14));
 252         Assert.assertFalse("Wrong -- unregister MultipartRequestTFSerializer by not existing key",
 253                 provider.unregisterSerializer(key14));
 254         // -- registerMeterBandSerializer
 255         final ExperimenterIdMeterSubTypeSerializerKey<MeterBandExperimenterCase> key15
 256             = new ExperimenterIdMeterSubTypeSerializerKey<>(EncodeConstants.OF_VERSION_1_0, Uint32.valueOf(42),
 257                     MeterBandExperimenterCase.class,null);
 258         provider.registerMeterBandSerializer(key15, serializerMeterBandExpCase);
 259         Assert.assertTrue("Wrong -- unregister MeterBandSerializer", provider.unregisterSerializer(key15));
 260         Assert.assertFalse("Wrong -- unregister MeterBandSerializer by not existing key",
 261                 provider.unregisterSerializer(key15));
 262         // -- registerMatchEntrySerializer
 263         final MatchEntrySerializerKey<OpenflowBasicClass, InPort> key16
 264             = new MatchEntrySerializerKey<>(EncodeConstants.OF_VERSION_1_3, OpenflowBasicClass.class, InPort.class);
 265         provider.registerMatchEntrySerializer(key16, serializer);
 266         Assert.assertTrue("Wrong -- unregister MatchEntrySerializer", provider.unregisterSerializer(key16));
 267         Assert.assertFalse("Wrong -- unregister MatchEntrySerializer by not existing key",
 268                 provider.unregisterSerializer(key15));
 269         // -- registerSerializer
 270         final MessageTypeKey key17 = new MessageTypeKey<>(EncodeConstants.OF_VERSION_1_3, TestSubType.class);
 271         provider.registerSerializer(key17, serializer);
 272         // -- registerDeserializer
 273         final MessageCodeKey key18 = new MessageCodeKey(EncodeConstants.OF_VERSION_1_3, 42, TestSubType.class);
 274         provider.registerDeserializer(key18, deserializer);
 275     }
 276
 277     private interface TestSubType extends ExperimenterActionSubType {
 278         // empty class - only used in test for comparation
 279     }
 280 }