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.vppclassifier;
  18
  19 import static io.fd.honeycomb.v3po.translate.v3po.test.ContextTestUtils.getMapping;
  20 import static io.fd.honeycomb.v3po.translate.v3po.test.ContextTestUtils.getMappingIid;
  21 import static org.junit.Assert.assertEquals;
  22 import static org.mockito.Matchers.any;
  23 import static org.mockito.Matchers.anyString;
  24 import static org.mockito.Mockito.doReturn;
  25 import static org.mockito.Mockito.mock;
  26 import static org.mockito.Mockito.times;
  27 import static org.mockito.Mockito.verify;
  28
  29 import com.google.common.base.Optional;
  30 import com.google.common.collect.Lists;
  31 import io.fd.honeycomb.v3po.translate.read.ReadFailedException;
  32 import io.fd.honeycomb.v3po.translate.spi.read.RootReaderCustomizer;
  33 import io.fd.honeycomb.v3po.translate.v3po.test.ListReaderCustomizerTest;
  34 import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
  35 import java.util.List;
  36 import java.util.concurrent.CompletableFuture;
  37 import org.junit.Test;
  38 import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.Mappings;
  39 import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.MappingsBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.Mapping;
  41 import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.MappingKey;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.HexString;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.PacketHandlingAction;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.VppClassifierState;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.VppClassifierStateBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.VppNode;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.vpp.classifier.state.ClassifyTable;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.vpp.classifier.state.ClassifyTableBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.classifier.rev150603.vpp.classifier.state.ClassifyTableKey;
  50 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  51 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  52 import org.openvpp.jvpp.dto.ClassifyTableIds;
  53 import org.openvpp.jvpp.dto.ClassifyTableIdsReply;
  54 import org.openvpp.jvpp.dto.ClassifyTableInfo;
  55 import org.openvpp.jvpp.dto.ClassifyTableInfoReply;
  56
  57 public class ClassifyTableReaderTest extends
  58     ListReaderCustomizerTest<ClassifyTable, ClassifyTableKey, ClassifyTableBuilder> {
  59
  60     private static final int TABLE_INDEX_1 = 1;
  61     private static final String TABLE_NAME_1 = "table1";
  62     private static final int TABLE_INDEX_2 = 2;
  63     private static final String TABLE_NAME_2 = "table2";
  64
  65     private NamingContext classifyTableContext;
  66
  67     public ClassifyTableReaderTest() {
  68         super(ClassifyTable.class);
  69     }
  70
  71     @Override
  72     public void setUpBefore() {
  73         classifyTableContext = new NamingContext("classifyTableContext", "test-instance");
  74
  75         final KeyedInstanceIdentifier<Mapping, MappingKey> t0Id = getMappingIid(TABLE_NAME_1, "test-instance");
  76         final KeyedInstanceIdentifier<Mapping, MappingKey> t1Id = getMappingIid(TABLE_NAME_2, "test-instance");
  77         final Optional<Mapping> t0 = getMapping(TABLE_NAME_1, TABLE_INDEX_1);
  78         final Optional<Mapping> t1 = getMapping(TABLE_NAME_2, TABLE_INDEX_2);
  79         final List<Mapping> allMappings = Lists.newArrayList(t0.get(), t1.get());
  80         final Mappings allMappingsBaObject = new MappingsBuilder().setMapping(allMappings).build();
  81         doReturn(Optional.of(allMappingsBaObject)).when(mappingContext).read(t0Id.firstIdentifierOf(Mappings.class));
  82         doReturn(t0).when(mappingContext).read(t0Id);
  83         doReturn(t1).when(mappingContext).read(t1Id);
  84     }
  85
  86     @Override
  87     protected RootReaderCustomizer<ClassifyTable, ClassifyTableBuilder> initCustomizer() {
  88         return new ClassifyTableReader(api, classifyTableContext);
  89     }
  90
  91     private static InstanceIdentifier<ClassifyTable> getClassifyTableId(final String name) {
  92         return InstanceIdentifier.create(VppClassifierState.class)
  93             .child(ClassifyTable.class, new ClassifyTableKey(name));
  94     }
  95
  96     private static ClassifyTableInfoReply generateClassifyTableInfoReply() {
  97         final ClassifyTableInfoReply reply = new ClassifyTableInfoReply();
  98         reply.tableId = TABLE_INDEX_1;
  99         reply.nbuckets = 2;
 100         reply.skipNVectors = 0;
 101         reply.matchNVectors = 1;
 102         reply.nextTableIndex = ~0;
 103         reply.missNextIndex = ~0;
 104         reply.mask =
 105             new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
 106                 (byte) 0x05, (byte) 0x06, 0x00, 0x00, 0x00, 0x00};
 107         return reply;
 108     }
 109
 110     private void verifyClasifyTableRead(final ClassifyTableBuilder builder) {
 111         verify(builder).setName(TABLE_NAME_1);
 112         verify(builder).setNbuckets(2L);
 113         verify(builder, times(0)).setNextTable(anyString());
 114         verify(builder).setMissNext(new VppNode(PacketHandlingAction.Permit));
 115         verify(builder).setMask(new HexString("00:00:00:00:00:00:01:02:03:04:05:06:00:00:00:00"));
 116         verify(builder).setActiveSessions(0L);
 117     }
 118
 119     @Test
 120     public void testMerge() {
 121         final VppClassifierStateBuilder builder = mock(VppClassifierStateBuilder.class);
 122         final List<ClassifyTable> value = mock(List.class);
 123         getCustomizer().merge(builder, value);
 124         verify(builder).setClassifyTable(value);
 125     }
 126
 127     @Test
 128     public void testRead() throws ReadFailedException {
 129         final CompletableFuture<ClassifyTableInfoReply> replyFuture = new CompletableFuture<>();
 130         replyFuture.complete(generateClassifyTableInfoReply());
 131         doReturn(replyFuture).when(api).classifyTableInfo(any(ClassifyTableInfo.class));
 132
 133         final ClassifyTableBuilder builder = mock(ClassifyTableBuilder.class);
 134         getCustomizer().readCurrentAttributes(getClassifyTableId(TABLE_NAME_1), builder, ctx);
 135
 136         verifyClasifyTableRead(builder);
 137     }
 138
 139     @Test
 140     public void testGetAllIds() throws ReadFailedException {
 141         final CompletableFuture<ClassifyTableIdsReply> replyFuture = new CompletableFuture<>();
 142         final ClassifyTableIdsReply reply = new ClassifyTableIdsReply();
 143         reply.ids = new int[] {1, 2};
 144         replyFuture.complete(reply);
 145         doReturn(replyFuture).when(api).classifyTableIds(any(ClassifyTableIds.class));
 146
 147         final List<ClassifyTableKey> allIds = getCustomizer().getAllIds(getClassifyTableId(TABLE_NAME_1), ctx);
 148
 149         assertEquals(reply.ids.length, allIds.size());
 150         assertEquals(TABLE_NAME_1, allIds.get(0).getName());
 151         assertEquals(TABLE_NAME_2, allIds.get(1).getName());
 152     }
 153 }