diff options
Diffstat (limited to 'vpp-common/vpp-translate-utils/src/test')
3 files changed, 312 insertions, 0 deletions
diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/cache/DumpCacheManagerTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/cache/DumpCacheManagerTest.java new file mode 100644 index 000000000..5b9391305 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/cache/DumpCacheManagerTest.java @@ -0,0 +1,143 @@ +/* + * 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.translate.v3po.util.cache; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.when; + +import com.google.common.base.Optional; +import io.fd.honeycomb.translate.v3po.util.cache.exceptions.check.i.DumpEmptyException; +import io.fd.honeycomb.translate.v3po.util.cache.exceptions.execution.DumpExecutionFailedException; +import io.fd.honeycomb.v3po.translate.ModificationCache; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.openvpp.jvpp.dto.IpDetails; +import org.openvpp.jvpp.dto.IpDetailsReplyDump; + +public class DumpCacheManagerTest { + + private static final String KEY = "cacheKey"; + + @Mock + private EntityDumpExecutor<IpDetailsReplyDump, Void> executor; + + private DumpCacheManager<IpDetailsReplyDump, Void> managerPositive; + private DumpCacheManager<IpDetailsReplyDump, Void> managerPositiveWithPostProcessing; + private DumpCacheManager<IpDetailsReplyDump, Void> managerNegative; + private ModificationCache cache; + + @Before + public void init() { + MockitoAnnotations.initMocks(this); + managerPositive = + new DumpCacheManager.DumpCacheManagerBuilder<IpDetailsReplyDump, Void>() + .withExecutor(executor) + .withNonEmptyPredicate(createPositivePredicate()) + .build(); + + managerPositiveWithPostProcessing = new DumpCacheManager.DumpCacheManagerBuilder<IpDetailsReplyDump, Void>() + .withExecutor(executor) + .withNonEmptyPredicate(createPositivePredicate()) + .withPostProcessingFunction(createPostProcessor()) + .build(); + + managerNegative = + new DumpCacheManager.DumpCacheManagerBuilder<IpDetailsReplyDump, Void>() + .withExecutor(executor) + .withNonEmptyPredicate(createNegativePredicate()) + .build(); + + cache = new ModificationCache(); + } + + /** + * This test verify full dump-caching cycle + */ + @Test + public void testCaching() throws DumpExecutionFailedException { + + + Optional<IpDetailsReplyDump> stage1Optional = managerNegative.getDump(KEY, cache); + + //this is first call so instance should be from executor + assertEquals(false, stage1Optional.isPresent()); + assertEquals(false, cache.containsKey(KEY)); + + //rebind executor with other data + IpDetailsReplyDump stage2LoadedDump = new IpDetailsReplyDump(); + when(executor.executeDump()).thenReturn(stage2LoadedDump); + + Optional<IpDetailsReplyDump> stage2Optional = managerPositive.getDump(KEY, cache); + + assertEquals(true, stage2Optional.isPresent()); + assertEquals(stage2LoadedDump, stage2Optional.get()); + + //rebind executor with other data + IpDetailsReplyDump stage3LoadedDump = new IpDetailsReplyDump(); + when(executor.executeDump()).thenReturn(stage3LoadedDump); + + Optional<IpDetailsReplyDump> stage3Optional = managerPositive.getDump(KEY, cache); + assertEquals(true, stage3Optional.isPresent()); + //check if it returns instance cached from previous stage + assertEquals(stage2LoadedDump, stage3Optional.get()); + } + + @Test + public void testPostprocessing() throws DumpExecutionFailedException { + IpDetailsReplyDump dump = new IpDetailsReplyDump(); + IpDetails details = new IpDetails(); + details.swIfIndex = 2; + dump.ipDetails.add(details); + + when(executor.executeDump()).thenReturn(dump); + + Optional<IpDetailsReplyDump> optionalDump = managerPositiveWithPostProcessing.getDump(KEY, cache); + + assertEquals(true, optionalDump.isPresent()); + assertEquals(1, optionalDump.get().ipDetails.size()); + assertEquals(7, optionalDump.get().ipDetails.get(0).swIfIndex); + } + + private EntityDumpNonEmptyCheck<IpDetailsReplyDump> createNegativePredicate() { + return data -> { + throw new DumpEmptyException("Empty dump", new IllegalArgumentException()); + }; + } + + private EntityDumpNonEmptyCheck<IpDetailsReplyDump> createPositivePredicate() { + return data -> { + //DO NOTHING + }; + } + + private EntityDumpPostProcessingFunction<IpDetailsReplyDump> createPostProcessor() { + return ipDetailsReplyDump -> { + IpDetailsReplyDump modified = new IpDetailsReplyDump(); + + for (IpDetails detail : ipDetailsReplyDump.ipDetails) { + IpDetails modifiedDetail = new IpDetails(); + modifiedDetail.swIfIndex = detail.swIfIndex + 5; + + modified.ipDetails.add(modifiedDetail); + } + + return modified; + }; + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/SubinterfaceUtilsTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/SubinterfaceUtilsTest.java new file mode 100644 index 000000000..a61dfea90 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/SubinterfaceUtilsTest.java @@ -0,0 +1,32 @@ +/* + * 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.util; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +public class SubinterfaceUtilsTest { + + @Test + public void testGetSubInterfaceName() throws Exception { + final String superIfName = "GigabitEthernet0/9/0"; + final int subIfaceId = 123; + final String expectedSubIfaceName = "GigabitEthernet0/9/0.123"; + assertEquals(expectedSubIfaceName, SubInterfaceUtils.getSubInterfaceName(superIfName, subIfaceId)); + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java new file mode 100644 index 000000000..334887430 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java @@ -0,0 +1,137 @@ +package io.fd.honeycomb.v3po.translate.v3po.util; + +import static io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils.reverseBytes; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.junit.Test; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone; +import org.opendaylight.yangtools.yang.binding.DataContainer; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.openvpp.jvpp.dto.JVppReply; + +public class TranslateUtilsTest { + + private static class AnDataObject implements DataObject { + @Override + public Class<? extends DataContainer> getImplementedInterface() { + return null; + } + } + + @Test + public void testGetReplyForWriteTimeout() throws Exception { + final Future<JVppReply<?>> future = mock(Future.class); + when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class); + final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class); + try { + TranslateUtils.getReplyForWrite(future, replyType); + } catch (WriteTimeoutException e) { + assertTrue(e.getCause() instanceof TimeoutException); + assertEquals(replyType, e.getFailedId()); + return; + } + fail("WriteTimeoutException was expected"); + } + + @Test + public void testGetReplyForReadTimeout() throws Exception { + final Future<JVppReply<?>> future = mock(Future.class); + final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class); + when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class); + try { + TranslateUtils.getReplyForRead(future, replyType); + } catch (ReadTimeoutException e) { + assertTrue(e.getCause() instanceof TimeoutException); + assertEquals(replyType, e.getFailedId()); + return; + } + fail("ReadTimeoutException was expected"); + } + + @Test + public void testIpv4NoZone() throws Exception { + final Ipv4AddressNoZone ipv4Addr = new Ipv4AddressNoZone("192.168.1.1"); + byte[] bytes = TranslateUtils.ipv4AddressNoZoneToArray(ipv4Addr); + assertEquals((byte)192, bytes[0]); + // Simulating the magic of VPP + bytes = reverseBytes(bytes); + final Ipv4AddressNoZone ipv4AddressNoZone = TranslateUtils.arrayToIpv4AddressNoZone(bytes); + assertEquals(ipv4Addr, ipv4AddressNoZone); + } + + @Test + public void testToString() { + final byte[] expected = "test".getBytes(); + final byte[] cString = new byte[expected.length + 10]; + System.arraycopy(expected, 0, cString, 0, expected.length); + final String jString = TranslateUtils.toString(cString); + assertArrayEquals(expected, jString.getBytes()); + } + + @Test + public void testParseMac() throws Exception { + byte[] bytes = TranslateUtils.parseMac("00:fF:7f:15:5e:A9"); + assertMac(bytes); + } + + private void assertMac(final byte[] bytes) { + assertEquals(6, bytes.length); + assertEquals((byte) 0, bytes[0]); + assertEquals((byte) 255, bytes[1]); + assertEquals((byte) 127, bytes[2]); + assertEquals((byte) 21, bytes[3]); + assertEquals((byte) 94, bytes[4]); + assertEquals((byte) 169, bytes[5]); + } + + @Test(expected = IllegalArgumentException.class) + public void testParseMacLonger() throws Exception { + byte[] bytes = TranslateUtils.parseMac("00:fF:7f:15:5e:A9:88:77"); + assertMac(bytes); + } + + @Test(expected = IllegalArgumentException.class) + public void testParseMacShorter() throws Exception { + TranslateUtils.parseMac("00:fF:7f"); + } + + @Test(expected = IllegalArgumentException.class) + public void testParseRandomString() throws Exception { + TranslateUtils.parseMac("random{}}@$*&*!"); + } + + @Test(expected = NumberFormatException.class) + public void testParseMacNumberFormatEx() throws Exception { + TranslateUtils.parseMac("00:XX:7f:15:5e:77\""); + } + + @Test + public void testBooleanToByte() { + assertEquals(0, TranslateUtils.booleanToByte(null)); + assertEquals(0, TranslateUtils.booleanToByte(false)); + assertEquals(1, TranslateUtils.booleanToByte(true)); + } + + @Test + public void testByteToBoolean() { + assertEquals(Boolean.FALSE, TranslateUtils.byteToBoolean((byte) 0)); + assertEquals(Boolean.TRUE, TranslateUtils.byteToBoolean((byte) 1)); + } + + @Test(expected = IllegalArgumentException.class) + public void testByteToBooleanFailed() { + TranslateUtils.byteToBoolean((byte) 123); + } + +}
\ No newline at end of file |