openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceContextImplTest.java

   1 package org.opendaylight.openflowplugin.impl.device;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.fail;
   5
   6 import com.google.common.util.concurrent.SettableFuture;
   7 import io.netty.util.HashedWheelTimer;
   8 import java.util.ArrayList;
   9 import java.util.Collections;
  10 import java.util.List;
  11 import java.util.concurrent.ExecutionException;
  12 import java.util.concurrent.TimeUnit;
  13 import java.util.concurrent.TimeoutException;
  14 import org.junit.Assert;
  15 import org.junit.Before;
  16 import org.junit.Test;
  17 import org.junit.runner.RunWith;
  18 import org.mockito.Mock;
  19 import org.mockito.Mockito;
  20 import org.mockito.runners.MockitoJUnitRunner;
  21 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
  25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  26 import org.opendaylight.openflowplugin.api.OFConstants;
  27 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  28 import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
  29 import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
  30 import org.opendaylight.openflowplugin.api.openflow.device.Xid;
  31 import org.opendaylight.openflowplugin.api.openflow.device.exception.DeviceDataException;
  32 import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageIntelligenceAgency;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartRequestFlags;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.Error;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ErrorMessageBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncOutput;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncOutputBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncReply;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReplyMessageBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.async.body.grouping.FlowRemovedMask;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.async.body.grouping.PacketInMask;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.async.body.grouping.PortStatusMask;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyDescCase;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyDescCaseBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.desc._case.MultipartReplyDesc;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.desc._case.MultipartReplyDescBuilder;
  49 import org.opendaylight.yangtools.yang.common.RpcError;
  50 import org.opendaylight.yangtools.yang.common.RpcResult;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 @RunWith(MockitoJUnitRunner.class)
  55 public class DeviceContextImplTest {
  56     private static final Logger LOG = LoggerFactory
  57             .getLogger(DeviceContextImplTest.class);
  58     Xid xid;
  59     Xid xidMulti;
  60     DeviceContextImpl deviceContext;
  61     TransactionChainManager txChainManager;
  62     @Mock
  63     RequestContext<GetAsyncReply> requestContext;
  64     @Mock
  65     RequestContext<MultipartReply> requestContextMultiReply;
  66
  67     @Mock
  68     ConnectionContext connectionContext;
  69     @Mock
  70     DeviceState deviceState;
  71     @Mock
  72     DataBroker dataBroker;
  73     @Mock
  74     WriteTransaction wTx;
  75     @Mock
  76     ReadOnlyTransaction rTx;
  77     @Mock
  78     BindingTransactionChain txChainFactory;
  79     @Mock
  80     HashedWheelTimer timer;
  81     @Mock
  82     MessageIntelligenceAgency messageIntelligenceAgency;
  83
  84     @Before
  85     public void setUp() {
  86         Mockito.when(dataBroker.createTransactionChain(Mockito.any(TransactionChainManager.class))).thenReturn(txChainFactory);
  87         txChainManager = new TransactionChainManager(dataBroker, timer, 5L);
  88         final SettableFuture<RpcResult<GetAsyncReply>> settableFuture = SettableFuture.create();
  89         final SettableFuture<RpcResult<MultipartReply>> settableFutureMultiReply = SettableFuture.create();
  90         Mockito.when(requestContext.getFuture()).thenReturn(settableFuture);
  91         Mockito.when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
  92         Mockito.when(txChainFactory.newWriteOnlyTransaction()).thenReturn(wTx);
  93         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
  94
  95         deviceContext = new DeviceContextImpl(connectionContext, deviceState, dataBroker, timer, messageIntelligenceAgency);
  96         xid = deviceContext.getNextXid();
  97         xidMulti = deviceContext.getNextXid();
  98     }
  99
 100     @Test(expected = NullPointerException.class)
 101     public void testDeviceContextImplConstructorNullConnectionContext() {
 102         new DeviceContextImpl(null, deviceState, dataBroker, timer, messageIntelligenceAgency);
 103     }
 104
 105     @Test(expected = NullPointerException.class)
 106     public void testDeviceContextImplConstructorNullDataBroker() {
 107         new DeviceContextImpl(connectionContext, deviceState, null, timer, messageIntelligenceAgency);
 108     }
 109
 110     @Test(expected = NullPointerException.class)
 111     public void testDeviceContextImplConstructorNullDeviceState() {
 112         new DeviceContextImpl(connectionContext, null, dataBroker, timer, messageIntelligenceAgency);
 113     }
 114
 115     @Test(expected = NullPointerException.class)
 116     public void testDeviceContextImplConstructorNullTimer() {
 117         new DeviceContextImpl(null, deviceState, dataBroker, null, messageIntelligenceAgency);
 118     }
 119
 120     @Test
 121     public void testGetDeviceState() {
 122         final DeviceState deviceSt = deviceContext.getDeviceState();
 123         Assert.assertNotNull(deviceSt);
 124         Assert.assertEquals(deviceState, deviceSt);
 125     }
 126
 127     @Test
 128     public void testGetReadTransaction() {
 129         final ReadTransaction readTx = deviceContext.getReadTransaction();
 130         Assert.assertNotNull(readTx);
 131         Assert.assertEquals(rTx, readTx);
 132     }
 133
 134     private static GetAsyncOutput createAsyncOutput(final Xid xid) {
 135         final GetAsyncOutputBuilder asyncOutputBuilder = new GetAsyncOutputBuilder();
 136         asyncOutputBuilder.setFlowRemovedMask(Collections.<FlowRemovedMask>emptyList());
 137         asyncOutputBuilder.setPacketInMask(Collections.<PacketInMask>emptyList());
 138         asyncOutputBuilder.setPortStatusMask(Collections.<PortStatusMask>emptyList());
 139         asyncOutputBuilder.setVersion(OFConstants.OFP_VERSION_1_3);
 140         asyncOutputBuilder.setXid(xid.getValue());
 141         return asyncOutputBuilder.build();
 142     }
 143
 144     @Test
 145     public void testProcessReply() {
 146         final GetAsyncOutput asyncOutput = createAsyncOutput(xid);
 147         LOG.info("Hooking RequestContext");
 148         deviceContext.hookRequestCtx(xid, requestContext);
 149         Assert.assertEquals(requestContext, deviceContext.lookupRequest(xid));
 150
 151         Assert.assertFalse(requestContext.getFuture().isDone());
 152         LOG.info("Sending reply from device");
 153         deviceContext.processReply(asyncOutput);
 154         Assert.assertTrue(requestContext.getFuture().isDone());
 155
 156         LOG.info("Checking RequestContext.future");
 157         try {
 158             final Object object = requestContext.getFuture().get(1L, TimeUnit.SECONDS);
 159             final RpcResult<OfHeader> rpcResult = (RpcResult<OfHeader>) object;
 160             final GetAsyncOutput getAsyncOutput = (GetAsyncOutput) rpcResult.getResult();
 161             assertEquals(asyncOutput.getVersion(), getAsyncOutput.getVersion());
 162         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 163             LOG.error("Test failed when checking RequestContext.future", e);
 164             fail("fail");
 165         }
 166         Assert.assertTrue(deviceContext.getNumberOfOutstandingRequests() == 0);
 167     }
 168
 169     private static Error createError(final Xid xid) {
 170         final ErrorMessageBuilder errorMessageBuilder = new ErrorMessageBuilder();
 171         errorMessageBuilder.setCode(42);
 172         errorMessageBuilder.setCodeString("42");
 173         errorMessageBuilder.setXid(xid.getValue());
 174         return errorMessageBuilder.build();
 175     }
 176
 177     @Test
 178     public void testProcessReplyError() {
 179         LOG.info("Hooking RequestContext");
 180         deviceContext.hookRequestCtx(xid, requestContext);
 181         Assert.assertEquals(requestContext, deviceContext.lookupRequest(xid));
 182
 183         Assert.assertFalse(requestContext.getFuture().isDone());
 184         LOG.info("Sending error reply from device");
 185         final Error error = createError(xid);
 186         deviceContext.processReply(error);
 187         Assert.assertTrue(requestContext.getFuture().isDone());
 188
 189         LOG.info("Checking RequestContext.future");
 190         try {
 191             final Object object = requestContext.getFuture().get(1L, TimeUnit.SECONDS);
 192             final RpcResult<OfHeader> rpcResult = (RpcResult<OfHeader>) object;
 193             Assert.assertFalse(rpcResult.isSuccessful());
 194             final List<RpcError> errors = (List<RpcError>) rpcResult.getErrors();
 195             Assert.assertTrue(errors.get(0).getCause() instanceof DeviceDataException);
 196             final DeviceDataException cause = (DeviceDataException) errors.get(0).getCause();
 197             Assert.assertEquals(error, cause.getError());
 198         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 199             LOG.error("Test failed when checking RequestContext.future", e);
 200             fail("fail");
 201         }
 202         Assert.assertTrue(deviceContext.getNumberOfOutstandingRequests() == 0);
 203     }
 204
 205     @Test
 206     public void testProcessReplyList() {
 207         LOG.info("Hooking RequestContext");
 208         deviceContext.hookRequestCtx(xidMulti, requestContextMultiReply);
 209         Assert.assertEquals(requestContextMultiReply, deviceContext.lookupRequest(xidMulti));
 210
 211         Assert.assertFalse(requestContextMultiReply.getFuture().isDone());
 212         LOG.info("Sending reply from device");
 213         deviceContext.processReply(xidMulti, createMultipartReplyList(xidMulti));
 214         Assert.assertTrue(requestContextMultiReply.getFuture().isDone());
 215
 216         LOG.info("Checking RequestContext.future");
 217         try {
 218             final Object object = requestContextMultiReply.getFuture().get(1L, TimeUnit.SECONDS);
 219             final RpcResult<List<OfHeader>> rpcResult = (RpcResult<List<OfHeader>>) object;
 220             final List<OfHeader> multipartReplies = rpcResult.getResult();
 221             final List<MultipartReply> expectedMpReplies = createMultipartReplyList(xidMulti);
 222             assertEquals(expectedMpReplies, multipartReplies);
 223         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 224             LOG.error("Test failed when checking RequestContext.future", e);
 225             fail("fail");
 226         }
 227         Assert.assertTrue(deviceContext.getNumberOfOutstandingRequests() == 0);
 228     }
 229
 230     private static List<MultipartReply> createMultipartReplyList(final Xid xid) {
 231         final MultipartReplyDesc descValue = new MultipartReplyDescBuilder().setHwDesc("hw-test-value").build();
 232         final MultipartReplyDescCase replyBody = new MultipartReplyDescCaseBuilder()
 233                 .setMultipartReplyDesc(descValue).build();
 234         final List<MultipartReply> multipartReplies = new ArrayList<>();
 235         multipartReplies.add(new MultipartReplyMessageBuilder()
 236                 .setMultipartReplyBody(replyBody)
 237                 .setXid(xid.getValue())
 238                 .setFlags(new MultipartRequestFlags(false))
 239                 .build());
 240         multipartReplies.add(new MultipartReplyMessageBuilder()
 241                 .setMultipartReplyBody(replyBody)
 242                 .setXid(xid.getValue())
 243                 .setFlags(new MultipartRequestFlags(true))
 244                 .build());
 245         return multipartReplies;
 246     }
 247
 248     @Test
 249     public void testProcessException() {
 250         LOG.info("Hooking RequestContext");
 251         deviceContext.hookRequestCtx(xid, requestContext);
 252         Assert.assertEquals(requestContext, deviceContext.lookupRequest(xid));
 253
 254         Assert.assertFalse(requestContext.getFuture().isDone());
 255
 256         LOG.info("Sending reply from device");
 257         deviceContext.processException(xid, new DeviceDataException("Some freakin' error", new NullPointerException()));
 258         Assert.assertTrue(requestContext.getFuture().isDone());
 259
 260         LOG.info("Checking RequestContext.future");
 261         try {
 262             final Object object = requestContext.getFuture().get(1L, TimeUnit.SECONDS);
 263             final RpcResult<OfHeader> rpcResult = (RpcResult<OfHeader>) object;
 264             Assert.assertFalse(rpcResult.isSuccessful());
 265             final List<RpcError> errors = (List<RpcError>) rpcResult.getErrors();
 266             Assert.assertTrue(errors.get(0).getCause() instanceof DeviceDataException);
 267             final DeviceDataException cause = (DeviceDataException) errors.get(0).getCause();
 268             Assert.assertTrue(cause.getCause() instanceof NullPointerException);
 269         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 270             LOG.error("Test failed when checking RequestContext.future", e);
 271             fail("fail");
 272         }
 273         Assert.assertTrue(deviceContext.getNumberOfOutstandingRequests() == 0);
 274     }
 275
 276 }