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

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