gerrit.fd Code Review - hc2vpp.git/blob

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package io.fd.honeycomb.v3po.translate.v3po.interfaces.ip;
  18
  19 import static io.fd.honeycomb.v3po.translate.v3po.test.ContextTestUtils.mockMapping;
  20 import static org.junit.Assert.assertArrayEquals;
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertTrue;
  23 import static org.junit.Assert.fail;
  24 import static org.mockito.Matchers.any;
  25 import static org.mockito.Mockito.doReturn;
  26 import static org.mockito.Mockito.verify;
  27 import static org.mockito.MockitoAnnotations.initMocks;
  28
  29 import com.google.common.base.Optional;
  30 import io.fd.honeycomb.v3po.translate.MappingContext;
  31 import io.fd.honeycomb.v3po.translate.v3po.test.TestHelperUtils;
  32 import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
  33 import io.fd.honeycomb.v3po.translate.write.WriteContext;
  34 import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
  35 import java.util.Arrays;
  36 import java.util.List;
  37 import java.util.concurrent.CompletableFuture;
  38 import org.junit.Before;
  39 import org.junit.Test;
  40 import org.mockito.ArgumentCaptor;
  41 import org.mockito.Mock;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4Builder;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.AddressBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.Netmask;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.NetmaskBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLength;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLengthBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
  57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  58 import org.openvpp.jvpp.VppBaseCallException;
  59 import org.openvpp.jvpp.VppInvocationException;
  60 import org.openvpp.jvpp.dto.SwInterfaceAddDelAddress;
  61 import org.openvpp.jvpp.dto.SwInterfaceAddDelAddressReply;
  62 import org.openvpp.jvpp.future.FutureJVpp;
  63
  64 public class Ipv4AddressCustomizerTest {
  65
  66     private static final String IFC_CTX_NAME = "ifc-test-instance";
  67     private static final String IFACE_NAME = "eth0";
  68     private static final int IFACE_ID = 123;
  69
  70     @Mock
  71     private WriteContext writeContext;
  72     @Mock
  73     private MappingContext mappingContext;
  74     @Mock
  75     private FutureJVpp api;
  76
  77     private NamingContext interfaceContext;
  78     private Ipv4AddressCustomizer customizer;
  79
  80     @Before
  81     public void setUp() throws Exception {
  82         initMocks(this);
  83         doReturn(mappingContext).when(writeContext).getMappingContext();
  84         interfaceContext = new NamingContext("generatedlIfaceName", IFC_CTX_NAME);
  85
  86         customizer = new Ipv4AddressCustomizer(api, interfaceContext);
  87     }
  88
  89     private static InstanceIdentifier<Address> getAddressId(final String ifaceName) {
  90         return InstanceIdentifier.builder(Interfaces.class)
  91             .child(Interface.class, new InterfaceKey(ifaceName))
  92             .augmentation(Interface1.class)
  93             .child(Ipv4.class)
  94             .child(Address.class)
  95             .build();
  96     }
  97
  98     private void whenSwInterfaceAddDelAddressThenSuccess() {
  99         final CompletableFuture<SwInterfaceAddDelAddressReply> replyFuture = new CompletableFuture<>();
 100         final SwInterfaceAddDelAddressReply reply = new SwInterfaceAddDelAddressReply();
 101         replyFuture.complete(reply);
 102         doReturn(replyFuture).when(api).swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
 103     }
 104
 105     private void whenSwInterfaceAddDelAddressThenFailure() {
 106         doReturn(TestHelperUtils.createFutureException()).when(api)
 107             .swInterfaceAddDelAddress(any(SwInterfaceAddDelAddress.class));
 108     }
 109
 110     private void verifySwInterfaceAddDelAddressWasInvoked(final SwInterfaceAddDelAddress expected) throws
 111         VppInvocationException {
 112         ArgumentCaptor<SwInterfaceAddDelAddress> argumentCaptor =
 113             ArgumentCaptor.forClass(SwInterfaceAddDelAddress.class);
 114         verify(api).swInterfaceAddDelAddress(argumentCaptor.capture());
 115         verifySwInterfaceAddDelAddressWasInvoked(expected, argumentCaptor.getValue());
 116     }
 117
 118     private void verifySwInterfaceAddDelAddressWasInvoked(final SwInterfaceAddDelAddress expected,
 119                                                           final SwInterfaceAddDelAddress actual) throws
 120         VppInvocationException {
 121         assertArrayEquals(expected.address, actual.address);
 122         assertEquals(expected.addressLength, actual.addressLength);
 123         assertEquals(expected.delAll, actual.delAll);
 124         assertEquals(expected.isAdd, actual.isAdd);
 125         assertEquals(expected.isIpv6, actual.isIpv6);
 126         assertEquals(expected.swIfIndex, actual.swIfIndex);
 127     }
 128
 129     @Test
 130     public void testAddPrefixLengthIpv4Address() throws Exception {
 131         final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
 132
 133         Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
 134         PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
 135         Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
 136
 137         mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
 138         whenSwInterfaceAddDelAddressThenSuccess();
 139
 140         customizer.writeCurrentAttributes(id, data, writeContext);
 141
 142         verifySwInterfaceAddDelAddressWasInvoked(generateSwInterfaceAddDelAddressRequest(new byte[] {-64, -88, 2, 1},
 143             (byte) 1, (byte) 24));
 144     }
 145
 146     @Test
 147     public void testAddPrefixLengthIpv4AddressFailed() throws Exception {
 148         final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
 149
 150         Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
 151         PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
 152         Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
 153
 154         mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
 155         whenSwInterfaceAddDelAddressThenFailure();
 156
 157         try {
 158             customizer.writeCurrentAttributes(id, data, writeContext);
 159         } catch (WriteFailedException e) {
 160             assertTrue(e.getCause() instanceof VppBaseCallException);
 161             verifySwInterfaceAddDelAddressWasInvoked(
 162                 generateSwInterfaceAddDelAddressRequest(new byte[] {-64, -88, 2, 1},
 163                     (byte) 1, (byte) 24));
 164             return;
 165         }
 166         fail("WriteFailedException was expected");
 167     }
 168
 169     private SwInterfaceAddDelAddress generateSwInterfaceAddDelAddressRequest(final byte[] address, final byte isAdd,
 170                                                                              final byte prefixLength) {
 171         final SwInterfaceAddDelAddress request = new SwInterfaceAddDelAddress();
 172         request.swIfIndex = IFACE_ID;
 173         request.isAdd = isAdd;
 174         request.isIpv6 = 0;
 175         request.delAll = 0;
 176         request.addressLength = prefixLength;
 177         request.address = address;
 178         return request;
 179     }
 180
 181     @Test
 182     public void testDeletePrefixLengthIpv4Address() throws Exception {
 183         final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
 184
 185         Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
 186         PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
 187         Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
 188
 189         mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
 190         whenSwInterfaceAddDelAddressThenSuccess();
 191
 192         customizer.deleteCurrentAttributes(id, data, writeContext);
 193
 194         verifySwInterfaceAddDelAddressWasInvoked(generateSwInterfaceAddDelAddressRequest(new byte[] {-64, -88, 2, 1},
 195             (byte) 0, (byte) 24));
 196     }
 197
 198     @Test
 199     public void testDeletePrefixLengthIpv4AddressFailed() throws Exception {
 200         final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
 201
 202         Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
 203         PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build();
 204         Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(length).build();
 205
 206         mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
 207         whenSwInterfaceAddDelAddressThenFailure();
 208
 209         try {
 210             customizer.deleteCurrentAttributes(id, data, writeContext);
 211         } catch (WriteFailedException e) {
 212             assertTrue(e.getCause() instanceof VppBaseCallException);
 213             verifySwInterfaceAddDelAddressWasInvoked(
 214                 generateSwInterfaceAddDelAddressRequest(new byte[] {-64, -88, 2, 1},
 215                     (byte) 0, (byte) 24));
 216             return;
 217         }
 218         fail("WriteFailedException was expec16ted");
 219     }
 220
 221     @Test
 222     public void testExtract() {
 223         final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
 224
 225         Address address = new AddressBuilder().build();
 226         Ipv4 parentData = new Ipv4Builder().setAddress(Arrays.asList(address)).build();
 227
 228         Optional<List<Address>> addressesOptional = customizer.extract(id, parentData);
 229
 230         assertEquals(true, addressesOptional.isPresent());
 231         assertEquals(1, addressesOptional.get().size());
 232         assertEquals(true, addressesOptional.get().contains(address));
 233     }
 234
 235     private void testSingleNetmask(final int expectedPrefixLength, final String stringMask) throws Exception {
 236         final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
 237
 238         Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
 239         Netmask subnet = new NetmaskBuilder().setNetmask(new DottedQuad(stringMask)).build();
 240         Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
 241
 242         mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
 243
 244         final CompletableFuture<SwInterfaceAddDelAddressReply> replyFuture = new CompletableFuture<>();
 245         replyFuture.complete(new SwInterfaceAddDelAddressReply());
 246         ArgumentCaptor<SwInterfaceAddDelAddress> argumentCaptor =
 247             ArgumentCaptor.forClass(SwInterfaceAddDelAddress.class);
 248         doReturn(replyFuture).when(api).swInterfaceAddDelAddress(argumentCaptor.capture());
 249
 250         customizer.writeCurrentAttributes(id, data, writeContext);
 251
 252         verifySwInterfaceAddDelAddressWasInvoked(generateSwInterfaceAddDelAddressRequest(new byte[] {-64, -88, 2, 1},
 253             (byte) 1, (byte) expectedPrefixLength), argumentCaptor.getValue());
 254     }
 255
 256     private void testSingleIllegalNetmask(final String stringMask) throws Exception {
 257         try {
 258             final InstanceIdentifier<Address> id = getAddressId(IFACE_NAME);
 259
 260             Ipv4AddressNoZone noZoneIp = new Ipv4AddressNoZone(new Ipv4Address("192.168.2.1"));
 261             Netmask subnet = new NetmaskBuilder().setNetmask(new DottedQuad(stringMask)).build();
 262             Address data = new AddressBuilder().setIp(noZoneIp).setSubnet(subnet).build();
 263
 264             mockMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME);
 265
 266             final CompletableFuture<SwInterfaceAddDelAddressReply> replyFuture = new CompletableFuture<>();
 267             replyFuture.complete(new SwInterfaceAddDelAddressReply());
 268             ArgumentCaptor<SwInterfaceAddDelAddress> argumentCaptor =
 269                 ArgumentCaptor.forClass(SwInterfaceAddDelAddress.class);
 270             doReturn(replyFuture).when(api).swInterfaceAddDelAddress(argumentCaptor.capture());
 271
 272             customizer.writeCurrentAttributes(id, data, writeContext);
 273         } catch (IllegalArgumentException e) {
 274             return;
 275         }
 276         fail("IllegalArgumentException expected");
 277
 278     }
 279
 280     /**
 281      * Test contiguous netmask length from QuadDotted notation
 282      */
 283     @Test
 284     public void testNetmaskLength() throws Exception {
 285         testSingleNetmask(1, "128.0.0.0");
 286         testSingleNetmask(2, "192.0.0.0");
 287         testSingleNetmask(8, "255.0.0.0");
 288         testSingleNetmask(9, "255.128.0.0");
 289         testSingleNetmask(16, "255.255.0.0");
 290         testSingleNetmask(24, "255.255.255.0");
 291     }
 292
 293     @Test
 294     public void testNetmaskIllegal() throws Exception {
 295         testSingleIllegalNetmask("");
 296         testSingleIllegalNetmask(".");
 297         testSingleIllegalNetmask(".255");
 298         testSingleIllegalNetmask("255");
 299         testSingleIllegalNetmask("255.");
 300         testSingleIllegalNetmask("255.255");
 301         testSingleIllegalNetmask("255.255.0");
 302         testSingleIllegalNetmask("255.255.255.");
 303         testSingleIllegalNetmask("255.255.255.256");
 304         testSingleIllegalNetmask("0.0.0.0");
 305         testSingleIllegalNetmask("10.10.10.10");
 306         testSingleIllegalNetmask("255.1.255.0");
 307         testSingleIllegalNetmask("255.255.255.255");
 308     }
 309
 310 }