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