HONEYCOMB-9: Remove references to VPP from translation layer

Change-Id: I281db366a112edc08203e8cb392a212708d4552a
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>

1 files changed, 259 insertions, 0 deletions

diff --git a/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/v3po/translate/v3po/vppstate/VppStateTest.java b/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/v3po/translate/v3po/vppstate/VppStateTest.java
new file mode 100644
index 000000000..6f53f6519
--- /dev/null
+++ b/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/v3po/translate/v3po/vppstate/VppStateTest.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.v3po.translate.v3po.vppstate;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
+import io.fd.honeycomb.v3po.translate.impl.read.CompositeListReader;
+import io.fd.honeycomb.v3po.translate.impl.read.CompositeRootReader;
+import io.fd.honeycomb.v3po.translate.util.read.DelegatingReaderRegistry;
+import io.fd.honeycomb.v3po.translate.read.ReadContext;
+import io.fd.honeycomb.v3po.translate.read.Reader;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Matchers;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppState;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppStateBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.BridgeDomains;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.Version;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.VersionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.BridgeDomainKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.bridge.domain.L2Fib;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.state.bridge.domains.bridge.domain.L2FibKey;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.vppjapi.vppApi;
+import org.openvpp.vppjapi.vppBridgeDomainDetails;
+import org.openvpp.vppjapi.vppBridgeDomainInterfaceDetails;
+import org.openvpp.vppjapi.vppL2Fib;
+import org.openvpp.vppjapi.vppVersion;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@SuppressStaticInitializationFor("org.openvpp.vppjapi.vppConn")
+@PrepareForTest(vppApi.class)
+public class VppStateTest {
+
+    public static final vppVersion VERSION = new vppVersion("test", "1", "2", "33");
+
+    private vppApi api;
+    private CompositeRootReader<VppState, VppStateBuilder> vppStateReader;
+    private DelegatingReaderRegistry readerRegistry;
+    private vppBridgeDomainDetails bdDetails;
+    private vppBridgeDomainDetails bdDetails2;
+    private ReadContext ctx;
+
+    @Before
+    public void setUp() throws Exception {
+        api = PowerMockito.mock(vppApi.class);
+
+        ctx = mock(ReadContext.class);
+
+        bdDetails = new vppBridgeDomainDetails();
+        setIfcs(bdDetails);
+        setBaseAttrs(bdDetails, "bdn1", 1);
+
+        bdDetails2 = new vppBridgeDomainDetails();
+        setIfcs(bdDetails2);
+        setBaseAttrs(bdDetails2, "bdn2", 2);
+
+        final vppL2Fib[] l2Fibs = getL2Fibs();
+        PowerMockito.doReturn(l2Fibs).when(api).l2FibTableDump(Matchers.anyInt());
+        PowerMockito.doAnswer(new Answer<vppBridgeDomainDetails>() {
+
+            @Override
+            public vppBridgeDomainDetails answer(final InvocationOnMock invocationOnMock) throws Throwable {
+                final Integer idx = (Integer) invocationOnMock.getArguments()[0];
+                switch (idx) {
+                    case 1 : return bdDetails;
+                    case 2 : return bdDetails2;
+                    default: return null;
+                }
+            }
+        }).when(api).getBridgeDomainDetails(Matchers.anyInt());
+
+        PowerMockito.doAnswer(new Answer<Object>() {
+            @Override
+            public Object answer(final InvocationOnMock invocationOnMock) throws Throwable {
+                final String name = (String) invocationOnMock.getArguments()[0];
+                switch (name) {
+                    case "bdn1" : return 1;
+                    case "bdn2" : return 2;
+                    default: return null;
+                }
+            }
+        }).when(api).bridgeDomainIdFromName(anyString());
+        PowerMockito.doReturn(new int[] {1, 2}).when(api).bridgeDomainDump(Matchers.anyInt());
+        PowerMockito.doReturn(VERSION).when(api).getVppVersion();
+        vppStateReader = VppStateUtils.getVppStateReader(api);
+        readerRegistry = new DelegatingReaderRegistry(Collections.<Reader<? extends DataObject>>singletonList(vppStateReader));
+    }
+
+    private vppL2Fib[] getL2Fibs() {
+        return new vppL2Fib[] {
+            new vppL2Fib(new byte[]{1,2,3,4,5,6}, true, "ifc1", true, true),
+            new vppL2Fib(new byte[]{2,2,3,4,5,6}, true, "ifc2", true, true),
+        };
+    }
+
+    private void setIfcs(final vppBridgeDomainDetails bdDetails) {
+        final vppBridgeDomainInterfaceDetails ifcDetails = new vppBridgeDomainInterfaceDetails();
+        ifcDetails.interfaceName = "ifc";
+        ifcDetails.splitHorizonGroup = 2;
+        bdDetails.interfaces = new vppBridgeDomainInterfaceDetails[] {ifcDetails};
+    }
+
+    private void setBaseAttrs(final vppBridgeDomainDetails bdDetails, final String bdn, final int i) {
+        bdDetails.name = bdn;
+        bdDetails.arpTerm = true;
+        bdDetails.bdId = i;
+        bdDetails.bviInterfaceName = "ifc";
+        bdDetails.flood = true;
+        bdDetails.forward = true;
+        bdDetails.learn = true;
+        bdDetails.uuFlood = true;
+    }
+
+    @Test
+    public void testReadAll() throws Exception {
+        final Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> dataObjects = readerRegistry.readAll(ctx);
+        assertEquals(dataObjects.size(), 1);
+        final DataObject dataObject = Iterables.getOnlyElement(dataObjects.get(Iterables.getOnlyElement(dataObjects.keySet())));
+        assertTrue(dataObject instanceof VppState);
+        assertVersion((VppState) dataObject);
+        assertEquals(2, ((VppState) dataObject).getBridgeDomains().getBridgeDomain().size());
+    }
+
+    private void assertVersion(final VppState dataObject) {
+        assertEquals(
+            new VersionBuilder()
+                .setName("test")
+                .setBuildDirectory("1")
+                .setBranch("2")
+                .setBuildDate("33")
+                .build(),
+            dataObject.getVersion());
+    }
+
+    @Test
+    public void testReadSpecific() throws Exception {
+        final Optional<? extends DataObject> read = readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx);
+        assertTrue(read.isPresent());
+        assertVersion((VppState) read.get());
+    }
+
+    @Test
+    public void testReadBridgeDomains() throws Exception {
+        VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
+
+        Optional<? extends DataObject> read =
+            readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class), ctx);
+        assertTrue(read.isPresent());
+        assertEquals(readRoot.getBridgeDomains(), read.get());
+    }
+
+    /**
+     * L2fib does not have a dedicated reader, relying on auto filtering
+     */
+    @Test
+    public void testReadL2Fib() throws Exception {
+        // Deep child without a dedicated reader with specific l2fib key
+        Optional<? extends DataObject> read =
+            readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
+                BridgeDomain.class, new BridgeDomainKey("bdn1"))
+                .child(L2Fib.class, new L2FibKey(new PhysAddress("01:02:03:04:05:06"))), ctx);
+        assertTrue(read.isPresent());
+
+        // non existing l2fib
+        read =
+            readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
+                BridgeDomain.class, new BridgeDomainKey("bdn1"))
+                .child(L2Fib.class, new L2FibKey(new PhysAddress("FF:FF:FF:04:05:06"))), ctx);
+        assertFalse(read.isPresent());
+    }
+
+    @Test
+    public void testReadBridgeDomainAll() throws Exception {
+        VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
+
+        final CompositeListReader<BridgeDomain, BridgeDomainKey, BridgeDomainBuilder> bridgeDomainReader =
+            VppStateUtils.getBridgeDomainReader(api);
+
+        final List<BridgeDomain> read =
+            bridgeDomainReader.readList(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
+                BridgeDomain.class), ctx);
+
+        assertEquals(readRoot.getBridgeDomains().getBridgeDomain(), read);
+    }
+
+    @Test
+    public void testReadBridgeDomain() throws Exception {
+        VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
+
+        final Optional<? extends DataObject> read =
+            readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
+                BridgeDomain.class, new BridgeDomainKey("bdn1")), ctx);
+
+        assertTrue(read.isPresent());
+        assertEquals(Iterables.find(readRoot.getBridgeDomains().getBridgeDomain(), new Predicate<BridgeDomain>() {
+            @Override
+            public boolean apply(final BridgeDomain input) {
+                return input.getKey().getName().equals("bdn1");
+            }
+        }), read.get());
+    }
+
+    // FIXME
+    @Ignore("Bridge domain customizer does not check whether the bd exists or not and fails with NPE, add it there")
+    @Test
+    public void testReadBridgeDomainNotExisting() throws Exception {
+        final Optional<? extends DataObject> read =
+            readerRegistry.read(InstanceIdentifier.create(VppState.class).child(BridgeDomains.class).child(
+                BridgeDomain.class, new BridgeDomainKey("NOT EXISTING")), ctx);
+        assertFalse(read.isPresent());
+    }
+
+    @Test
+    public void testReadVersion() throws Exception {
+        VppState readRoot = (VppState) readerRegistry.read(InstanceIdentifier.create(VppState.class), ctx).get();
+
+        Optional<? extends DataObject> read =
+            readerRegistry.read(InstanceIdentifier.create(VppState.class).child(Version.class), ctx);
+        assertTrue(read.isPresent());
+        assertEquals(readRoot.getVersion(), read.get());
+    }
+}
\ No newline at end of file