openflowjava/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/serialization/factories/ExperimenterInputMessageFactoryTest.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
   9 package org.opendaylight.openflowjava.protocol.impl.serialization.factories;
  10
  11 import static org.mockito.ArgumentMatchers.any;
  12
  13 import io.netty.buffer.ByteBuf;
  14 import org.junit.Test;
  15 import org.mockito.Mock;
  16 import org.mockito.Mockito;
  17 import org.mockito.MockitoAnnotations;
  18 import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
  19 import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
  20 import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistryInjector;
  21 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
  22 import org.opendaylight.openflowjava.protocol.impl.serialization.SerializerRegistryImpl;
  23 import org.opendaylight.openflowjava.protocol.impl.util.BufferHelper;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.ExperimenterId;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInput;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterInputBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterOfMessage;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
  29
  30 /**
  31  * Unit tests for ExperimenterInputMessageFactory.
  32  *
  33  * @author michal.polkorab
  34  */
  35 public class ExperimenterInputMessageFactoryTest {
  36
  37     @Mock SerializerRegistry registry;
  38     @Mock
  39     private OFSerializer<ExperimenterDataOfChoice> serializer;
  40     private OFSerializer<ExperimenterOfMessage> expFactory;
  41     @Mock
  42     private ExperimenterDataOfChoice vendorData;
  43     @Mock
  44     private ByteBuf out;
  45
  46     /**
  47      * Sets up ExperimenterInputMessageFactory.
  48      * @param real true if setup should use real registry, false when mock is desired
  49      */
  50     public void startUp(boolean real) {
  51         MockitoAnnotations.initMocks(this);
  52         expFactory = new ExperimenterInputMessageFactory();
  53         if (real) {
  54             SerializerRegistry realRegistry = new SerializerRegistryImpl();
  55             realRegistry.init();
  56             ((SerializerRegistryInjector) expFactory).injectSerializerRegistry(realRegistry);
  57         } else {
  58             ((SerializerRegistryInjector) expFactory).injectSerializerRegistry(registry);
  59         }
  60     }
  61
  62     /**
  63      * Testing of {@link ExperimenterInputMessageFactory} for correct serializer
  64      * lookup and serialization.
  65      */
  66     @Test(expected = IllegalStateException.class)
  67     public void testV10Real() throws Exception {
  68         startUp(true);
  69         ExperimenterInputBuilder builder = new ExperimenterInputBuilder();
  70         BufferHelper.setupHeader(builder, EncodeConstants.OF10_VERSION_ID);
  71         builder.setExperimenter(new ExperimenterId(42L));
  72         builder.setExpType(21L);
  73         builder.setExperimenterDataOfChoice(vendorData);
  74         ExperimenterInput input = builder.build();
  75
  76         expFactory.serialize(input, out);
  77     }
  78
  79     /**
  80      * Testing of {@link ExperimenterInputMessageFactory} for correct serializer
  81      * lookup and serialization.
  82      */
  83     @Test(expected = IllegalStateException.class)
  84     public void testV13Real() throws Exception {
  85         startUp(true);
  86         ExperimenterInputBuilder builder = new ExperimenterInputBuilder();
  87         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
  88         builder.setExperimenter(new ExperimenterId(42L));
  89         builder.setExpType(22L);
  90         builder.setExperimenterDataOfChoice(vendorData);
  91         ExperimenterInput input = builder.build();
  92
  93         expFactory.serialize(input, out);
  94     }
  95
  96     /**
  97      * Testing of {@link ExperimenterInputMessageFactory} for correct serializer
  98      * lookup and serialization.
  99      */
 100     @Test
 101     public void testV10() throws Exception {
 102         startUp(false);
 103         ExperimenterInputBuilder builder = new ExperimenterInputBuilder();
 104         BufferHelper.setupHeader(builder, EncodeConstants.OF10_VERSION_ID);
 105         builder.setExperimenter(new ExperimenterId(42L));
 106         builder.setExpType(21L);
 107         builder.setExperimenterDataOfChoice(vendorData);
 108         ExperimenterInput input = builder.build();
 109
 110         Mockito.when(registry.getSerializer(
 111             any())).thenReturn(serializer);
 112
 113         expFactory.serialize(input, out);
 114         Mockito.verify(serializer, Mockito.times(1)).serialize(input.getExperimenterDataOfChoice(), out);
 115     }
 116
 117     /**
 118      * Testing of {@link ExperimenterInputMessageFactory} for correct serializer
 119      * lookup and serialization.
 120      */
 121     @Test
 122     public void testV13() throws Exception {
 123         startUp(false);
 124         ExperimenterInputBuilder builder = new ExperimenterInputBuilder();
 125         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 126         builder.setExperimenter(new ExperimenterId(42L));
 127         builder.setExpType(21L);
 128         builder.setExperimenterDataOfChoice(vendorData);
 129         ExperimenterInput input = builder.build();
 130
 131         Mockito.when(registry.getSerializer(
 132             any())).thenReturn(serializer);
 133
 134         expFactory.serialize(input, out);
 135         Mockito.verify(serializer, Mockito.times(1)).serialize(input.getExperimenterDataOfChoice(), out);
 136     }
 137 }