pcep/topology-provider/src/test/java/org/opendaylight/bgpcep/pcep/topology/provider/ParserToSalTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco 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 package org.opendaylight.bgpcep.pcep.topology.provider;
   9
  10 import static org.mockito.Matchers.any;
  11 import static org.mockito.Mockito.doAnswer;
  12 import static org.mockito.Mockito.doReturn;
  13 import static org.mockito.Mockito.mock;
  14 import io.netty.channel.Channel;
  15 import io.netty.channel.ChannelFuture;
  16 import io.netty.channel.ChannelHandler;
  17 import io.netty.channel.ChannelPipeline;
  18 import io.netty.util.HashedWheelTimer;
  19 import io.netty.util.concurrent.Promise;
  20
  21 import java.io.IOException;
  22 import java.net.InetSocketAddress;
  23 import java.net.SocketAddress;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.concurrent.ExecutionException;
  27 import java.util.concurrent.Future;
  28 import java.util.concurrent.TimeUnit;
  29 import java.util.concurrent.TimeoutException;
  30
  31 import org.junit.After;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.mockito.Matchers;
  35 import org.mockito.Mock;
  36 import org.mockito.Mockito;
  37 import org.mockito.MockitoAnnotations;
  38 import org.mockito.invocation.InvocationOnMock;
  39 import org.mockito.stubbing.Answer;
  40 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  41 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
  42 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
  43 import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiator;
  44 import org.opendaylight.protocol.pcep.impl.PCEPSessionImpl;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Pcrpt;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.PcrptBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.PlspId;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.SymbolicPathName;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.object.LspBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.Open;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.open.TlvsBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrpt.message.PcrptMessageBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrpt.message.pcrpt.message.Reports;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrpt.message.pcrpt.message.ReportsBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.stateful.capability.tlv.StatefulBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.symbolic.path.name.tlv.SymbolicPathNameBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  59 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  60 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  62 import org.opendaylight.yangtools.yang.binding.DataObject;
  63 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  64 import org.opendaylight.yangtools.yang.binding.Notification;
  65 import org.opendaylight.yangtools.yang.common.RpcResult;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 import com.google.common.collect.Lists;
  70
  71 public class ParserToSalTest {
  72
  73         private static final Logger LOG = LoggerFactory.getLogger(ParserToSalTest.class);
  74
  75         private List<Notification> receivedMsgs;
  76
  77         private PCEPSessionImpl session;
  78
  79         @Mock
  80         private Channel clientListener;
  81
  82         @Mock
  83         private ChannelPipeline pipeline;
  84
  85         @Mock
  86         DataProviderService providerService;
  87
  88         @Mock
  89         DataModificationTransaction mockedTransaction;
  90
  91         private final Open localPrefs = new OpenBuilder().setDeadTimer((short) 30).setKeepalive((short) 10).setTlvs(
  92                         new TlvsBuilder().setStateful(new StatefulBuilder().build()).build()).build();
  93
  94         private Pcrpt rptmsg;
  95
  96         private ServerSessionManager manager;
  97
  98         @Before
  99         public void setUp() throws IOException {
 100                 MockitoAnnotations.initMocks(this);
 101
 102                 doAnswer(new Answer<Object>() {
 103                         @Override
 104                         public Object answer(final InvocationOnMock invocation) {
 105                                 final Object[] args = invocation.getArguments();
 106                                 ParserToSalTest.this.receivedMsgs.add((Notification) args[0]);
 107                                 return mock(ChannelFuture.class);
 108                         }
 109                 }).when(this.clientListener).writeAndFlush(any(Notification.class));
 110                 doReturn("TestingChannel").when(this.clientListener).toString();
 111                 doReturn(this.pipeline).when(this.clientListener).pipeline();
 112                 doReturn(this.pipeline).when(this.pipeline).replace(any(ChannelHandler.class), any(String.class), any(ChannelHandler.class));
 113                 doReturn(true).when(this.clientListener).isActive();
 114                 final SocketAddress ra = new InetSocketAddress("127.0.0.1", 4189);
 115                 doReturn(ra).when(this.clientListener).remoteAddress();
 116                 final SocketAddress la = new InetSocketAddress("127.0.0.1", 30000);
 117                 doReturn(la).when(this.clientListener).localAddress();
 118
 119                 doReturn(mock(ChannelFuture.class)).when(this.clientListener).close();
 120
 121                 Mockito.doReturn(this.mockedTransaction).when(this.providerService).beginTransaction();
 122                 Mockito.doReturn(new Future<RpcResult<TransactionStatus>>() {
 123                         int i = 0;
 124
 125                         @Override
 126                         public boolean cancel(final boolean mayInterruptIfRunning) {
 127                                 LOG.debug("Cancel.");
 128                                 return false;
 129                         }
 130
 131                         @Override
 132                         public boolean isCancelled() {
 133                                 LOG.debug("Is cancelled.");
 134                                 return false;
 135                         }
 136
 137                         @Override
 138                         public boolean isDone() {
 139                                 this.i++;
 140                                 LOG.debug("Done. {}", this.i);
 141                                 return true;
 142                         }
 143
 144                         @Override
 145                         public RpcResult<TransactionStatus> get() throws InterruptedException, ExecutionException {
 146                                 return null;
 147                         }
 148
 149                         @Override
 150                         public RpcResult<TransactionStatus> get(final long timeout, final TimeUnit unit) throws InterruptedException,
 151                         ExecutionException, TimeoutException {
 152                                 return null;
 153                         }
 154                 }).when(this.mockedTransaction).commit();
 155
 156                 final HashMap<Object, Object> data = new HashMap<>();
 157
 158                 Mockito.doAnswer(new Answer<Object>() {
 159                         @Override
 160                         public Object answer(final InvocationOnMock invocation) throws Throwable {
 161                                 final Object[] args = invocation.getArguments();
 162                                 LOG.debug("Get key {}", args[0]);
 163                                 return data.get(args[0]);
 164                         }
 165
 166                 }).when(this.mockedTransaction).readOperationalData(Matchers.any(InstanceIdentifier.class));
 167
 168                 Mockito.doAnswer(new Answer<Object>() {
 169                         @Override
 170                         public Object answer(final InvocationOnMock invocation) throws Throwable {
 171                                 final Object[] args = invocation.getArguments();
 172                                 LOG.debug("Get key {}", args[0]);
 173                                 return data.get(args[0]);
 174                         }
 175
 176                 }).when(this.providerService).readOperationalData(Matchers.any(InstanceIdentifier.class));
 177
 178                 Mockito.doAnswer(new Answer<Object>() {
 179
 180                         @Override
 181                         public Object answer(final InvocationOnMock invocation) throws Throwable {
 182                                 data.remove(invocation.getArguments()[0]);
 183                                 return null;
 184                         }
 185
 186                 }).when(this.mockedTransaction).removeOperationalData(Matchers.any(InstanceIdentifier.class));
 187
 188                 Mockito.doAnswer(new Answer<String>() {
 189                         @Override
 190                         public String answer(final InvocationOnMock invocation) throws Throwable {
 191                                 final Object[] args = invocation.getArguments();
 192                                 LOG.debug("Put key {} value {}", args[0]);
 193                                 LOG.debug("Put value {}", args[1]);
 194                                 data.put(args[0], args[1]);
 195                                 return null;
 196                         }
 197
 198                 }).when(this.mockedTransaction).putOperationalData(Matchers.any(InstanceIdentifier.class), Matchers.any(DataObject.class));
 199
 200                 manager = new ServerSessionManager(this.providerService, InstanceIdentifier.builder(
 201                                 NetworkTopology.class).child(Topology.class, new TopologyKey(new TopologyId("testtopo"))).toInstance());
 202                 final DefaultPCEPSessionNegotiator neg = new DefaultPCEPSessionNegotiator(new HashedWheelTimer(), mock(Promise.class), this.clientListener, manager.getSessionListener(), (short) 1, 5, this.localPrefs);
 203                 this.session = neg.createSession(new HashedWheelTimer(), this.clientListener, this.localPrefs, this.localPrefs);
 204
 205                 final List<Reports> reports = Lists.newArrayList(new ReportsBuilder().setLsp(
 206                                 new LspBuilder().setPlspId(new PlspId(5L)).setSync(false).setRemove(false).setTlvs(
 207                                                 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.object.lsp.TlvsBuilder().setSymbolicPathName(
 208                                                                 new SymbolicPathNameBuilder().setPathName(new SymbolicPathName(new byte[] { 22, 34 })).build()).build()).build()).build());
 209                 this.rptmsg = new PcrptBuilder().setPcrptMessage(new PcrptMessageBuilder().setReports(reports).build()).build();
 210         }
 211
 212         @After
 213         public void tearDown() throws InterruptedException, ExecutionException {
 214                 manager.close();
 215         }
 216
 217         @Test
 218         public void testUnknownLsp() {
 219                 this.session.sessionUp();
 220                 this.session.handleMessage(this.rptmsg);
 221                 Mockito.verify(this.mockedTransaction, Mockito.times(4)).putOperationalData(Matchers.any(InstanceIdentifier.class),
 222                                 Matchers.any(DataObject.class));
 223                 Mockito.verify(this.mockedTransaction, Mockito.times(3)).commit();
 224         }
 225 }