bgp/parser-spi/src/test/java/org/opendaylight/protocol/bgp/parser/spi/pojo/SimpleRegistryTest.java

   1 /*
   2  * Copyright (c) 2014 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
   9 package org.opendaylight.protocol.bgp.parser.spi.pojo;
  10
  11 import static org.junit.Assert.assertArrayEquals;
  12 import static org.junit.Assert.assertEquals;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.mock;
  15 import static org.mockito.Mockito.times;
  16 import static org.mockito.Mockito.verify;
  17 import io.netty.buffer.ByteBuf;
  18 import io.netty.buffer.Unpooled;
  19 import java.util.Optional;
  20 import org.junit.After;
  21 import org.junit.Before;
  22 import org.junit.Test;
  23 import org.mockito.Mockito;
  24 import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
  25 import org.opendaylight.protocol.bgp.parser.BGPParsingException;
  26 import org.opendaylight.protocol.bgp.parser.spi.AddressFamilyRegistry;
  27 import org.opendaylight.protocol.bgp.parser.spi.AttributeRegistry;
  28 import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
  29 import org.opendaylight.protocol.bgp.parser.spi.BgpPrefixSidTlvRegistry;
  30 import org.opendaylight.protocol.bgp.parser.spi.CapabilityRegistry;
  31 import org.opendaylight.protocol.bgp.parser.spi.MessageRegistry;
  32 import org.opendaylight.protocol.bgp.parser.spi.MultiPathSupport;
  33 import org.opendaylight.protocol.bgp.parser.spi.NlriRegistry;
  34 import org.opendaylight.protocol.bgp.parser.spi.ParameterRegistry;
  35 import org.opendaylight.protocol.bgp.parser.spi.PeerConstraint;
  36 import org.opendaylight.protocol.bgp.parser.spi.PeerSpecificParserConstraint;
  37 import org.opendaylight.protocol.bgp.parser.spi.SubsequentAddressFamilyRegistry;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.message.BgpParameters;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.AttributesBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.bgp.prefix.sid.bgp.prefix.sid.tlvs.BgpPrefixSidTlv;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpReachNlri;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpReachNlriBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpUnreachNlri;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpUnreachNlriBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.Ipv4AddressFamily;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.Ipv6AddressFamily;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.UnicastSubsequentAddressFamily;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.next.hop.c.next.hop.Ipv4NextHopCaseBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.next.hop.c.next.hop.ipv4.next.hop._case.Ipv4NextHopBuilder;
  51 import org.opendaylight.yangtools.yang.binding.DataObject;
  52 import org.opendaylight.yangtools.yang.binding.Notification;
  53
  54 public class SimpleRegistryTest {
  55
  56     private static final MultiPathSupport ADD_PATH_SUPPORT = tableType -> true;
  57
  58     private static final PeerSpecificParserConstraint CONSTRAINT = new PeerSpecificParserConstraint() {
  59         @Override
  60         public <T extends PeerConstraint> Optional<T> getPeerConstraint(final Class<T> peerConstraintType) {
  61             return (Optional<T>) Optional.of(ADD_PATH_SUPPORT);
  62         }
  63     };
  64
  65     protected BGPExtensionProviderContext ctx;
  66     private BgpTestActivator activator;
  67
  68     @Before
  69     public void setUp() {
  70         this.ctx = ServiceLoaderBGPExtensionProviderContext.getSingletonInstance();
  71         this.activator = new BgpTestActivator();
  72         this.activator.start(this.ctx);
  73     }
  74
  75     @After
  76     public void tearDown() {
  77         this.activator.close();
  78     }
  79
  80     @Test
  81     public void testSimpleAttribute() throws BGPDocumentedException, BGPParsingException {
  82         final AttributeRegistry attrReg = this.ctx.getAttributeRegistry();
  83         final byte[] attributeBytes = {
  84             0x00, 0x00, 0x00
  85         };
  86         final ByteBuf byteAggregator = Unpooled.buffer(attributeBytes.length);
  87         attrReg.serializeAttribute(Mockito.mock(DataObject.class), byteAggregator);
  88         attrReg.parseAttributes(Unpooled.wrappedBuffer(attributeBytes), CONSTRAINT);
  89         verify(this.activator.attrParser, times(1)).parseAttribute(Mockito.any(ByteBuf.class), Mockito.any(AttributesBuilder.class),
  90             Mockito.any(PeerSpecificParserConstraint.class));
  91         verify(this.activator.attrSerializer, times(1)).serializeAttribute(Mockito.any(DataObject.class), Mockito.any(ByteBuf.class));
  92     }
  93
  94     @Test
  95     public void testSimpleParameter() throws Exception {
  96         final ParameterRegistry paramReg = this.ctx.getParameterRegistry();
  97         final BgpParameters param = Mockito.mock(BgpParameters.class);
  98         Mockito.doReturn(BgpParameters.class).when(param).getImplementedInterface();
  99         final byte[] paramBytes = {
 100             0x00, 0x00
 101         };
 102         final ByteBuf buffer = Unpooled.buffer(paramBytes.length);
 103         paramReg.serializeParameter(param, buffer);
 104         paramReg.parseParameter(0, Unpooled.wrappedBuffer(paramBytes));
 105         verify(this.activator.paramParser, times(1)).parseParameter(Mockito.any(ByteBuf.class));
 106         verify(this.activator.paramSerializer, times(1)).serializeParameter(Mockito.any(BgpParameters.class), Mockito.any(ByteBuf.class));
 107     }
 108
 109     @Test
 110     public void testSimpleCapability() throws Exception {
 111         final CapabilityRegistry capaRegistry = this.ctx.getCapabilityRegistry();
 112         final byte[] capabilityBytes = {
 113             0x0, 0x00
 114         };
 115         capaRegistry.parseCapability(BgpTestActivator.TYPE, Unpooled.wrappedBuffer(capabilityBytes));
 116         verify(this.activator.capaParser, times(1)).parseCapability(Mockito.any(ByteBuf.class));
 117     }
 118
 119     @Test
 120     public void testSimpleBgpPrefixSidTlvRegistry() {
 121         final BgpPrefixSidTlvRegistry sidTlvReg = this.ctx.getBgpPrefixSidTlvRegistry();
 122         final byte[] tlvBytes = {
 123             0x00, 0x03, 0x00, 0x00, 0x00
 124         };
 125
 126         final BgpPrefixSidTlv tlv = mock(BgpPrefixSidTlv.class);
 127         doReturn(BgpPrefixSidTlv.class).when(tlv).getImplementedInterface();
 128
 129         final ByteBuf buffer = Unpooled.buffer(tlvBytes.length);
 130         sidTlvReg.serializeBgpPrefixSidTlv(tlv, buffer);
 131         verify(this.activator.sidTlvSerializer, times(1)).serializeBgpPrefixSidTlv(Mockito.any(BgpPrefixSidTlv.class), Mockito.any(ByteBuf.class));
 132
 133         sidTlvReg.parseBgpPrefixSidTlv(BgpTestActivator.TYPE, Unpooled.wrappedBuffer(tlvBytes));
 134         verify(this.activator.sidTlvParser, times(1)).parseBgpPrefixSidTlv(Mockito.any(ByteBuf.class));
 135     }
 136
 137     @Test
 138     public void testSimpleMessageRegistry() throws Exception {
 139         final MessageRegistry msgRegistry = this.ctx.getMessageRegistry();
 140
 141         final byte[] msgBytes = {
 142             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 143             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 144             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 145             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 146             (byte) 0x00, (byte) 0x13, (byte) 0x00
 147         };
 148         final Notification msg = mock(Notification.class);
 149         doReturn(Notification.class).when(msg).getImplementedInterface();
 150
 151         final ByteBuf buffer = Unpooled.buffer(msgBytes.length);
 152         msgRegistry.serializeMessage(msg, buffer);
 153         msgRegistry.parseMessage(Unpooled.wrappedBuffer(msgBytes), CONSTRAINT);
 154         verify(this.activator.msgParser, times(1)).parseMessageBody(Mockito.any(ByteBuf.class), Mockito.anyInt(),
 155             Mockito.any(PeerSpecificParserConstraint.class));
 156         verify(this.activator.msgSerializer, times(1)).serializeMessage(Mockito.any(Notification.class), Mockito.any(ByteBuf.class));
 157     }
 158
 159     @Test
 160     public void testAfiRegistry() throws Exception {
 161         final AddressFamilyRegistry afiRegistry = this.ctx.getAddressFamilyRegistry();
 162         assertEquals(Ipv4AddressFamily.class, afiRegistry.classForFamily(1));
 163         assertEquals(1, afiRegistry.numberForClass(Ipv4AddressFamily.class).intValue());
 164     }
 165
 166     @Test
 167     public void testSafiRegistry() throws Exception {
 168         final SubsequentAddressFamilyRegistry safiRegistry = this.ctx.getSubsequentAddressFamilyRegistry();
 169         assertEquals(UnicastSubsequentAddressFamily.class, safiRegistry.classForFamily(1));
 170         assertEquals(1, safiRegistry.numberForClass(UnicastSubsequentAddressFamily.class).intValue());
 171     }
 172
 173     @Test
 174     public void testMpReachParser() throws BGPParsingException {
 175         final NlriRegistry nlriReg = this.ctx.getNlriRegistry();
 176         final byte[] mpReachBytes = {
 177             0x00, 0x01, 0x01, 0x04, 0x7f, 0x00, 0x00, 0x01, 0x00
 178         };
 179         final MpReachNlri mpReach = new MpReachNlriBuilder()
 180             .setAfi(Ipv4AddressFamily.class)
 181             .setSafi(UnicastSubsequentAddressFamily.class)
 182             .setCNextHop(new Ipv4NextHopCaseBuilder().setIpv4NextHop(new Ipv4NextHopBuilder().setGlobal(new Ipv4Address("127.0.0.1")).build()).build())
 183             .build();
 184         final ByteBuf buffer = Unpooled.buffer(mpReachBytes.length);
 185         nlriReg.serializeMpReach(mpReach, buffer);
 186         assertArrayEquals(mpReachBytes, buffer.array());
 187         assertEquals(mpReach, nlriReg.parseMpReach(Unpooled.wrappedBuffer(mpReachBytes), CONSTRAINT));
 188         verify(this.activator.nlriParser, times(1)).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpReachNlriBuilder.class), Mockito.any());
 189     }
 190
 191     @Test
 192     public void testMpReachWithZeroNextHop() throws BGPParsingException {
 193         final NlriRegistry nlriReg = this.ctx.getNlriRegistry();
 194         final byte[] mpReachBytes = {
 195             0x00, 0x01, 0x01, 0x00, 0x00
 196         };
 197         final MpReachNlri mpReach = new MpReachNlriBuilder()
 198             .setAfi(Ipv4AddressFamily.class)
 199             .setSafi(UnicastSubsequentAddressFamily.class)
 200             .build();
 201         final ByteBuf buffer = Unpooled.buffer(mpReachBytes.length);
 202         nlriReg.serializeMpReach(mpReach, buffer);
 203         assertArrayEquals(mpReachBytes, buffer.array());
 204         assertEquals(mpReach, nlriReg.parseMpReach(Unpooled.wrappedBuffer(mpReachBytes), CONSTRAINT));
 205     }
 206
 207     @Test
 208     public void testMpReachIpv6() throws BGPParsingException {
 209         final NlriRegistry nlriReg = this.ctx.getNlriRegistry();
 210         final byte[] mpReachBytes = {
 211             0x00, 0x02, 0x01, 0x00, 0x00
 212         };
 213         final MpReachNlri mpReach = new MpReachNlriBuilder()
 214             .setAfi(Ipv6AddressFamily.class)
 215             .setSafi(UnicastSubsequentAddressFamily.class)
 216             .build();
 217         final ByteBuf buffer = Unpooled.buffer(mpReachBytes.length);
 218         nlriReg.serializeMpReach(mpReach, buffer);
 219         assertArrayEquals(mpReachBytes, buffer.array());
 220         assertEquals(mpReach, nlriReg.parseMpReach(Unpooled.wrappedBuffer(mpReachBytes), CONSTRAINT));
 221     }
 222
 223     @Test
 224     public void testMpUnReachParser() throws BGPParsingException {
 225         final NlriRegistry nlriReg = this.ctx.getNlriRegistry();
 226         final byte[] mpUnreachBytes = {
 227             0x00, 0x01, 0x01
 228         };
 229         final MpUnreachNlri mpUnreach = new MpUnreachNlriBuilder().setAfi(Ipv4AddressFamily.class).setSafi(UnicastSubsequentAddressFamily.class).build();
 230         final ByteBuf buffer = Unpooled.buffer(mpUnreachBytes.length);
 231         nlriReg.serializeMpUnReach(mpUnreach, buffer);
 232         assertArrayEquals(mpUnreachBytes, buffer.array());
 233         assertEquals(mpUnreach, nlriReg.parseMpUnreach(Unpooled.wrappedBuffer(mpUnreachBytes), CONSTRAINT));
 234         verify(this.activator.nlriParser, times(1)).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpUnreachNlriBuilder.class), Mockito.any());
 235     }
 236 }