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 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.CapabilityRegistry;
  30 import org.opendaylight.protocol.bgp.parser.spi.MessageRegistry;
  31 import org.opendaylight.protocol.bgp.parser.spi.NlriRegistry;
  32 import org.opendaylight.protocol.bgp.parser.spi.ParameterRegistry;
  33 import org.opendaylight.protocol.bgp.parser.spi.SubsequentAddressFamilyRegistry;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.BgpParameters;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.bgp.parameters.optional.capabilities.CParameters;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.AttributesBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpReachNlri;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpReachNlriBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpUnreachNlri;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.attributes.MpUnreachNlriBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.Ipv4AddressFamily;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.UnicastSubsequentAddressFamily;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.next.hop.c.next.hop.Ipv4NextHopCaseBuilder;
  45 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;
  46 import org.opendaylight.yangtools.yang.binding.DataObject;
  47 import org.opendaylight.yangtools.yang.binding.Notification;
  48
  49 public class SimpleRegistryTest {
  50
  51     protected BGPExtensionProviderContext ctx;
  52     private BgpTestActivator activator;
  53
  54     @Before
  55     public void setUp() {
  56         this.ctx = ServiceLoaderBGPExtensionProviderContext.getSingletonInstance();
  57         this.activator = new BgpTestActivator();
  58         this.activator.start(this.ctx);
  59     }
  60
  61     @After
  62     public void tearDown() {
  63         this.activator.close();
  64     }
  65
  66     @Test
  67     public void testSimpleAttribute() throws BGPDocumentedException, BGPParsingException {
  68         final AttributeRegistry attrReg = this.ctx.getAttributeRegistry();
  69         final byte[] attributeBytes = {
  70             0x00, 0x00, 0x00
  71         };
  72         final ByteBuf byteAggregator = Unpooled.buffer(attributeBytes.length);
  73         attrReg.serializeAttribute(Mockito.mock(DataObject.class), byteAggregator);
  74         attrReg.parseAttributes(Unpooled.wrappedBuffer(attributeBytes));
  75         verify(this.activator.attrParser, times(1)).parseAttribute(Mockito.any(ByteBuf.class), Mockito.any(AttributesBuilder.class));
  76         verify(this.activator.attrSerializer, times(1)).serializeAttribute(Mockito.any(DataObject.class), Mockito.any(ByteBuf.class));
  77     }
  78
  79     @Test
  80     public void testSimpleParameter() throws Exception {
  81         final ParameterRegistry paramReg = this.ctx.getParameterRegistry();
  82         final BgpParameters param = Mockito.mock(BgpParameters.class);
  83         Mockito.doReturn(BgpParameters.class).when(param).getImplementedInterface();
  84         final byte[] paramBytes = {
  85             0x00, 0x00
  86         };
  87         final ByteBuf buffer = Unpooled.buffer(paramBytes.length);
  88         paramReg.serializeParameter(param, buffer);
  89         paramReg.parseParameter(0, Unpooled.wrappedBuffer(paramBytes));
  90         verify(this.activator.paramParser, times(1)).parseParameter(Mockito.any(ByteBuf.class));
  91         verify(this.activator.paramSerializer, times(1)).serializeParameter(Mockito.any(BgpParameters.class), Mockito.any(ByteBuf.class));
  92     }
  93
  94     @Test
  95     public void testSimpleCapability() throws Exception {
  96         final CapabilityRegistry capaRegistry = this.ctx.getCapabilityRegistry();
  97         final byte[] capabilityBytes = {
  98             0x0, 0x00
  99         };
 100         final CParameters capa = Mockito.mock(CParameters.class);
 101         Mockito.doReturn(CParameters.class).when(capa).getImplementedInterface();
 102         final ByteBuf buffer = Unpooled.buffer(capabilityBytes.length);
 103         capaRegistry.serializeCapability(capa, buffer);
 104         capaRegistry.parseCapability(BgpTestActivator.TYPE, Unpooled.wrappedBuffer(capabilityBytes));
 105         verify(this.activator.capaParser, times(1)).parseCapability(Mockito.any(ByteBuf.class));
 106         verify(this.activator.capaSerializer, times(1)).serializeCapability(Mockito.any(CParameters.class), Mockito.any(ByteBuf.class));
 107     }
 108
 109     @Test
 110     public void testSimpleMessageRegistry() throws Exception {
 111         final MessageRegistry msgRegistry = this.ctx.getMessageRegistry();
 112
 113         final byte[] msgBytes = {
 114             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 115             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 116             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 117             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
 118             (byte) 0x00, (byte) 0x13, (byte) 0x00
 119         };
 120         final Notification msg = mock(Notification.class);
 121         doReturn(Notification.class).when(msg).getImplementedInterface();
 122
 123         final ByteBuf buffer = Unpooled.buffer(msgBytes.length);
 124         msgRegistry.serializeMessage(msg, buffer);
 125         msgRegistry.parseMessage(Unpooled.wrappedBuffer(msgBytes));
 126         verify(this.activator.msgParser, times(1)).parseMessageBody(Mockito.any(ByteBuf.class), Mockito.anyInt());
 127         verify(this.activator.msgSerializer, times(1)).serializeMessage(Mockito.any(Notification.class), Mockito.any(ByteBuf.class));
 128     }
 129
 130     @Test
 131     public void testAfiRegistry() throws Exception {
 132         final AddressFamilyRegistry afiRegistry = this.ctx.getAddressFamilyRegistry();
 133         assertEquals(Ipv4AddressFamily.class, afiRegistry.classForFamily(1));
 134         assertEquals(1, afiRegistry.numberForClass(Ipv4AddressFamily.class).intValue());
 135     }
 136
 137     @Test
 138     public void testSafiRegistry() throws Exception {
 139         final SubsequentAddressFamilyRegistry safiRegistry = this.ctx.getSubsequentAddressFamilyRegistry();
 140         assertEquals(UnicastSubsequentAddressFamily.class, safiRegistry.classForFamily(1));
 141         assertEquals(1, safiRegistry.numberForClass(UnicastSubsequentAddressFamily.class).intValue());
 142     }
 143
 144     @Test
 145     public void testMpReachParser() throws BGPParsingException {
 146         final NlriRegistry nlriReg = this.ctx.getNlriRegistry();
 147         final byte[] mpReachBytes = {
 148             0x00, 0x01, 0x01, 0x04, 0x7f, 0x00, 0x00, 0x01, 0x00
 149         };
 150         final MpReachNlri mpReach = new MpReachNlriBuilder()
 151             .setAfi(Ipv4AddressFamily.class)
 152             .setSafi(UnicastSubsequentAddressFamily.class)
 153             .setCNextHop(new Ipv4NextHopCaseBuilder().setIpv4NextHop(new Ipv4NextHopBuilder().setGlobal(new Ipv4Address("127.0.0.1")).build()).build())
 154             .build();
 155         final ByteBuf buffer = Unpooled.buffer(mpReachBytes.length);
 156         nlriReg.serializeMpReach(mpReach, buffer);
 157         assertArrayEquals(mpReachBytes, buffer.array());
 158         assertEquals(mpReach, nlriReg.parseMpReach(Unpooled.wrappedBuffer(mpReachBytes)));
 159         verify(this.activator.nlriParser, times(1)).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpReachNlriBuilder.class));
 160     }
 161
 162     @Test
 163     public void testMpUnReachParser() throws BGPParsingException {
 164         final NlriRegistry nlriReg = this.ctx.getNlriRegistry();
 165         final byte[] mpUnreachBytes = {
 166             0x00, 0x01, 0x01
 167         };
 168         final MpUnreachNlri mpUnreach = new MpUnreachNlriBuilder().setAfi(Ipv4AddressFamily.class).setSafi(UnicastSubsequentAddressFamily.class).build();
 169         final ByteBuf buffer = Unpooled.buffer(mpUnreachBytes.length);
 170         nlriReg.serializeMpUnReach(mpUnreach, buffer);
 171         assertArrayEquals(mpUnreachBytes, buffer.array());
 172         assertEquals(mpUnreach, nlriReg.parseMpUnreach(Unpooled.wrappedBuffer(mpUnreachBytes)));
 173         verify(this.activator.nlriParser, times(1)).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpUnreachNlriBuilder.class));
 174     }
 175 }