v3po/v3po2vpp/src/test/java/io/fd/honeycomb/translate/v3po/interfaces/pbb/PbbRewriteCustomizerTest.java

   1 package io.fd.honeycomb.translate.v3po.interfaces.pbb;
   2
   3 import static org.junit.Assert.assertArrayEquals;
   4 import static org.junit.Assert.assertEquals;
   5 import static org.junit.Assert.assertNotNull;
   6 import static org.junit.Assert.assertTrue;
   7 import static org.junit.Assert.fail;
   8 import static org.mockito.Matchers.any;
   9 import static org.mockito.Mockito.times;
  10 import static org.mockito.Mockito.verify;
  11 import static org.mockito.Mockito.when;
  12
  13 import io.fd.honeycomb.translate.vpp.util.NamingContext;
  14 import io.fd.honeycomb.translate.write.WriteFailedException;
  15 import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest;
  16 import io.fd.vpp.jvpp.VppCallbackException;
  17 import io.fd.vpp.jvpp.core.dto.L2InterfacePbbTagRewrite;
  18 import io.fd.vpp.jvpp.core.dto.L2InterfacePbbTagRewriteReply;
  19 import org.junit.Test;
  20 import org.mockito.ArgumentCaptor;
  21 import org.mockito.Captor;
  22 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pbb.types.rev161214.Operation;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.pbb.rev161214.PbbRewriteInterfaceAugmentation;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewrite;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.pbb.rev161214.interfaces._interface.PbbRewriteBuilder;
  30 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  31
  32 public class PbbRewriteCustomizerTest extends WriterCustomizerTest {
  33
  34     @Captor
  35     private ArgumentCaptor<L2InterfacePbbTagRewrite> rewriteArgumentCaptor;
  36
  37     private NamingContext interfaceContext;
  38     private PbbRewriteCustomizer customizer;
  39     private InstanceIdentifier<PbbRewrite> validId;
  40     private InstanceIdentifier<PbbRewrite> invalidId;
  41
  42     @Override
  43     protected void setUp() throws Exception {
  44         interfaceContext = new NamingContext("interface", "interface-context");
  45         customizer = new PbbRewriteCustomizer(api, interfaceContext);
  46
  47         defineMapping(mappingContext, "pbb-interface", 1, "interface-context");
  48         validId = InstanceIdentifier.create(Interfaces.class)
  49                 .child(Interface.class, new InterfaceKey("pbb-interface"))
  50                 .augmentation(PbbRewriteInterfaceAugmentation.class)
  51                 .child(PbbRewrite.class);
  52
  53         invalidId = InstanceIdentifier.create(PbbRewrite.class);
  54     }
  55
  56     @Test
  57     public void testWrite() throws WriteFailedException {
  58         whenRewriteThenSuccess();
  59         customizer.writeCurrentAttributes(validId, validData(), writeContext);
  60         verifyRewriteRequest(desiredSetResult());
  61     }
  62
  63     @Test
  64     public void testWriteFailedCallFailed() {
  65         whenRewriteThenFail();
  66         final PbbRewrite validData = validData();
  67         try {
  68             customizer.writeCurrentAttributes(validId, validData, writeContext);
  69         } catch (Exception e) {
  70             assertTrue(e instanceof WriteFailedException.CreateFailedException);
  71             assertTrue(e.getCause() instanceof VppCallbackException);
  72
  73             final WriteFailedException.CreateFailedException ex = ((WriteFailedException.CreateFailedException) e);
  74             assertEquals(validId, ex.getFailedId());
  75             assertEquals(validData, ex.getData());
  76             return;
  77         }
  78
  79         fail("Test should have failed");
  80     }
  81
  82     @Test
  83     public void testWriteFailedInvalidData() {
  84         verifyInvalidWriteDataCombination(invalidDataNoDestination());
  85         verifyInvalidWriteDataCombination(invalidDataNoSource());
  86         verifyInvalidWriteDataCombination(invalidDataNoItag());
  87         verifyInvalidWriteDataCombination(invalidDataNoOperation());
  88         verifyInvalidWriteDataCombination(invalidDataNoVlan());
  89     }
  90
  91     @Test
  92     public void testUpdate() throws WriteFailedException {
  93         whenRewriteThenSuccess();
  94         final PbbRewrite rewrite = validData();
  95         customizer.updateCurrentAttributes(validId, rewrite, rewrite, writeContext);
  96         verifyRewriteRequest(desiredSetResult());
  97     }
  98
  99     @Test
 100     public void testUpdateFailedCallFailed() {
 101         whenRewriteThenFail();
 102         final PbbRewrite invalidData = invalidDataNoVlan();
 103         final PbbRewrite validData = validData();
 104         try {
 105             customizer.updateCurrentAttributes(validId, invalidData, validData, writeContext);
 106         } catch (Exception e) {
 107             assertTrue(e instanceof WriteFailedException.UpdateFailedException);
 108             assertTrue(e.getCause() instanceof VppCallbackException);
 109
 110             final WriteFailedException.UpdateFailedException ex = ((WriteFailedException.UpdateFailedException) e);
 111             assertEquals(validId, ex.getFailedId());
 112             assertEquals(invalidData, ex.getDataBefore());
 113             assertEquals(validData, ex.getDataAfter());
 114             return;
 115         }
 116
 117         fail("Test should have failed");
 118     }
 119
 120     @Test
 121     public void testUpdateFailedInvalidData() {
 122         verifyInvalidUpdateDataCombination(invalidDataNoDestination());
 123         verifyInvalidUpdateDataCombination(invalidDataNoSource());
 124         verifyInvalidUpdateDataCombination(invalidDataNoItag());
 125         verifyInvalidUpdateDataCombination(invalidDataNoOperation());
 126         verifyInvalidUpdateDataCombination(invalidDataNoVlan());
 127     }
 128
 129     @Test
 130     public void testDelete() throws WriteFailedException {
 131         whenRewriteThenSuccess();
 132         customizer.deleteCurrentAttributes(validId, validData(), writeContext);
 133         verifyRewriteRequest(desiredDisableResult());
 134     }
 135
 136     @Test
 137     public void testDeleteFailedCallFailed() {
 138         whenRewriteThenFail();
 139         final PbbRewrite validData = validData();
 140         try {
 141             customizer.deleteCurrentAttributes(validId, validData, writeContext);
 142         } catch (Exception e) {
 143             assertTrue(e instanceof WriteFailedException.DeleteFailedException);
 144             assertTrue(e.getCause() instanceof VppCallbackException);
 145             assertEquals(validId, ((WriteFailedException.DeleteFailedException) e).getFailedId());
 146             return;
 147         }
 148
 149         fail("Test should have failed");
 150     }
 151
 152     @Test
 153     public void testDeleteFailedInvalidData() {
 154         verifyInvalidDeleteDataCombination(invalidDataNoDestination());
 155         verifyInvalidDeleteDataCombination(invalidDataNoSource());
 156         verifyInvalidDeleteDataCombination(invalidDataNoItag());
 157         verifyInvalidDeleteDataCombination(invalidDataNoOperation());
 158         verifyInvalidDeleteDataCombination(invalidDataNoVlan());
 159     }
 160
 161     private void whenRewriteThenSuccess() {
 162         when(api.l2InterfacePbbTagRewrite(any())).thenReturn(future(new L2InterfacePbbTagRewriteReply()));
 163     }
 164
 165     private void whenRewriteThenFail() {
 166         when(api.l2InterfacePbbTagRewrite(any())).thenReturn(failedFuture());
 167     }
 168
 169     private void verifyInvalidWriteDataCombination(final PbbRewrite invalidData) {
 170         try {
 171             customizer.writeCurrentAttributes(validId, invalidData, writeContext);
 172         } catch (Exception e) {
 173             assertTrue(e instanceof NullPointerException);
 174             return;
 175         }
 176
 177         fail("Verifying of invalid combination failed");
 178     }
 179
 180     private void verifyInvalidUpdateDataCombination(final PbbRewrite invalidData) {
 181         try {
 182             customizer.updateCurrentAttributes(validId, validData(), invalidData, writeContext);
 183         } catch (Exception e) {
 184             assertTrue(e instanceof NullPointerException);
 185             return;
 186         }
 187
 188         fail("Verifying of invalid combination failed");
 189     }
 190
 191
 192     private void verifyInvalidDeleteDataCombination(final PbbRewrite invalidData) {
 193         try {
 194             customizer.deleteCurrentAttributes(validId, invalidData, writeContext);
 195         } catch (Exception e) {
 196             assertTrue(e instanceof NullPointerException);
 197             return;
 198         }
 199
 200         fail("Verifying of invalid combination failed");
 201     }
 202
 203
 204     private L2InterfacePbbTagRewrite desiredSetResult() {
 205         final L2InterfacePbbTagRewrite desiredResult = new L2InterfacePbbTagRewrite();
 206         desiredResult.swIfIndex = 1;
 207         desiredResult.vtrOp = Operation.Pop2.getIntValue();
 208         desiredResult.bDmac = new byte[]{-69, -69, -69, -69, -69, -69};
 209         desiredResult.bSmac = new byte[]{-86, -86, -86, -86, -86, -86};
 210         desiredResult.bVlanid = 1;
 211         desiredResult.iSid = 2;
 212
 213         return desiredResult;
 214     }
 215
 216     private L2InterfacePbbTagRewrite desiredDisableResult() {
 217         final L2InterfacePbbTagRewrite desiredResult = new L2InterfacePbbTagRewrite();
 218         desiredResult.swIfIndex = 1;
 219         desiredResult.vtrOp = 0;
 220         desiredResult.bDmac = new byte[]{-69, -69, -69, -69, -69, -69};
 221         desiredResult.bSmac = new byte[]{-86, -86, -86, -86, -86, -86};
 222         desiredResult.bVlanid = 1;
 223         desiredResult.iSid = 2;
 224
 225         return desiredResult;
 226     }
 227
 228     private void verifyRewriteRequest(final L2InterfacePbbTagRewrite desiredResult) {
 229         verify(api, times(1)).l2InterfacePbbTagRewrite(rewriteArgumentCaptor.capture());
 230
 231         final L2InterfacePbbTagRewrite actualRequest = rewriteArgumentCaptor.getValue();
 232
 233         assertNotNull(actualRequest);
 234         assertEquals(actualRequest.bVlanid, desiredResult.bVlanid);
 235         assertEquals(actualRequest.iSid, desiredResult.iSid);
 236         assertEquals(actualRequest.vtrOp, desiredResult.vtrOp);
 237         assertEquals(actualRequest.outerTag, desiredResult.outerTag);
 238         assertArrayEquals(actualRequest.bDmac, desiredResult.bDmac);
 239         assertArrayEquals(actualRequest.bSmac, desiredResult.bSmac);
 240     }
 241
 242     private PbbRewrite invalidDataNoDestination() {
 243         return new PbbRewriteBuilder()
 244                 .setBVlanTagVlanId(1)
 245                 .setITagIsid(2L)
 246                 .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
 247                 .setInterfaceOperation(Operation.Pop2)
 248                 .build();
 249     }
 250
 251     private PbbRewrite invalidDataNoSource() {
 252         return new PbbRewriteBuilder()
 253                 .setBVlanTagVlanId(1)
 254                 .setITagIsid(2L)
 255                 .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
 256                 .setInterfaceOperation(Operation.Pop2)
 257                 .build();
 258     }
 259
 260     private PbbRewrite invalidDataNoItag() {
 261         return new PbbRewriteBuilder()
 262                 .setBVlanTagVlanId(1)
 263                 .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
 264                 .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
 265                 .setInterfaceOperation(Operation.Pop2)
 266                 .build();
 267     }
 268
 269     private PbbRewrite invalidDataNoVlan() {
 270         return new PbbRewriteBuilder()
 271                 .setITagIsid(2L)
 272                 .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
 273                 .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
 274                 .setInterfaceOperation(Operation.Pop2)
 275                 .build();
 276     }
 277
 278     private PbbRewrite invalidDataNoOperation() {
 279         return new PbbRewriteBuilder()
 280                 .setITagIsid(2L)
 281                 .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
 282                 .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
 283                 .setInterfaceOperation(Operation.Pop2)
 284                 .build();
 285     }
 286
 287     private PbbRewrite validData() {
 288         return new PbbRewriteBuilder()
 289                 .setBVlanTagVlanId(1)
 290                 .setITagIsid(2L)
 291                 .setSourceAddress(new MacAddress("aa:aa:aa:aa:aa:aa"))
 292                 .setDestinationAddress(new MacAddress("bb:bb:bb:bb:bb:bb"))
 293                 .setInterfaceOperation(Operation.Pop2)
 294                 .build();
 295     }
 296 }