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