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