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