From 3f30dc525498e4b82796692f8eba1a0cc129fd46 Mon Sep 17 00:00:00 2001 From: Maros Marsalek Date: Fri, 16 Sep 2016 09:50:48 +0200 Subject: HONEYCOMB-194 Raise unit test coverage of transle-impl to 80% Change-Id: I8d032e1a90004ee4bd6ebbae002a8e66a7e85919 Signed-off-by: Maros Marsalek --- .../translate/impl/read/GenericListReaderTest.java | 122 +++++++++++++++++++++ .../translate/impl/read/GenericReaderTest.java | 79 +++++++++++++ .../impl/write/GenericListWriterTest.java | 60 +++++++--- .../translate/impl/write/GenericWriterTest.java | 50 ++++++--- 4 files changed, 281 insertions(+), 30 deletions(-) create mode 100644 infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericListReaderTest.java create mode 100644 infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericReaderTest.java (limited to 'infra') diff --git a/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericListReaderTest.java b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericListReaderTest.java new file mode 100644 index 000000000..0dc916fb8 --- /dev/null +++ b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericListReaderTest.java @@ -0,0 +1,122 @@ +/* + * 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.impl.read; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.common.collect.Lists; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer; +import java.util.Collections; +import java.util.List; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataContainer; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.Identifiable; +import org.opendaylight.yangtools.yang.binding.Identifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class GenericListReaderTest { + + private static final InstanceIdentifier + DATA_OBJECT_ID = InstanceIdentifier.create(TestingData.class); + @Mock + private ListReaderCustomizer> customizer; + @Mock + private Builder builder; + @Mock + private TestingData data; + @Mock + private ReadContext ctx; + private GenericListReader> reader; + private List keys = Lists.newArrayList(new TestingData.TestingKey(), + new TestingData.TestingKey()); + + @SuppressWarnings("unchecked") + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + when(customizer.getBuilder(any(InstanceIdentifier.class))).thenReturn(builder); + when(customizer.getAllIds(DATA_OBJECT_ID, ctx)).thenReturn(keys); + reader = new GenericListReader<>(DATA_OBJECT_ID, customizer); + when(builder.build()).thenReturn(data); + } + + @Test + public void testGetBuilder() throws Exception { + assertEquals(builder, reader.getBuilder(DATA_OBJECT_ID)); + verify(customizer).getBuilder(DATA_OBJECT_ID); + } + + @Test + public void testManagedType() throws Exception { + assertEquals(DATA_OBJECT_ID, reader.getManagedDataObjectType()); + } + + @Test + public void testMerge() throws Exception { + reader.merge(builder, data); + verify(customizer).merge(builder, Collections.singletonList(data)); + } + + @Test + public void testAllIds() throws Exception { + assertEquals(keys, reader.getAllIds(DATA_OBJECT_ID, ctx)); + verify(customizer).getAllIds(DATA_OBJECT_ID, ctx); + } + + @Test + public void testRead() throws Exception { + reader.read(DATA_OBJECT_ID, ctx); + + verify(customizer).getBuilder(DATA_OBJECT_ID); + verify(customizer).readCurrentAttributes(DATA_OBJECT_ID, builder, ctx); + } + + @SuppressWarnings("unchecked") + @Test + public void testReadList() throws Exception { + reader.readList(DATA_OBJECT_ID, ctx); + + verify(customizer, times(2)).getBuilder(any(InstanceIdentifier.class)); + verify(customizer, times(2)) + .readCurrentAttributes(any(InstanceIdentifier.class), any(Builder.class), any(ReadContext.class)); + } + + static class TestingData implements DataObject, Identifiable { + + @Override + public Class getImplementedInterface() { + return DataObject.class; + } + + @Override + public TestingKey getKey() { + return new TestingKey(); + } + + static class TestingKey implements Identifier {} + } +} \ No newline at end of file diff --git a/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericReaderTest.java b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericReaderTest.java new file mode 100644 index 000000000..02baab2eb --- /dev/null +++ b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/read/GenericReaderTest.java @@ -0,0 +1,79 @@ +/* + * 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.impl.read; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class GenericReaderTest { + + private static final InstanceIdentifier + DATA_OBJECT_ID = InstanceIdentifier.create(DataObject.class); + @Mock + private ReaderCustomizer> customizer; + @Mock + private Builder builder; + @Mock + private DataObject data; + @Mock + private ReadContext ctx; + private GenericReader> reader; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + when(customizer.getBuilder(DATA_OBJECT_ID)).thenReturn(builder); + reader = new GenericReader<>(DATA_OBJECT_ID, customizer); + when(builder.build()).thenReturn(data); + } + + @Test + public void testGetBuilder() throws Exception { + assertEquals(builder, reader.getBuilder(DATA_OBJECT_ID)); + verify(customizer).getBuilder(DATA_OBJECT_ID); + } + + @Test + public void testManagedType() throws Exception { + assertEquals(DATA_OBJECT_ID, reader.getManagedDataObjectType()); + } + + @Test + public void testMerge() throws Exception { + reader.merge(builder, data); + verify(customizer).merge(builder, data); + } + + @Test + public void testRead() throws Exception { + reader.read(DATA_OBJECT_ID, ctx); + + verify(customizer).getBuilder(DATA_OBJECT_ID); + verify(customizer).readCurrentAttributes(DATA_OBJECT_ID, builder, ctx); + } +} \ No newline at end of file diff --git a/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericListWriterTest.java b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericListWriterTest.java index d8bf96d86..2f50ece79 100644 --- a/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericListWriterTest.java +++ b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericListWriterTest.java @@ -17,12 +17,13 @@ package io.fd.honeycomb.translate.impl.write; import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; import java.util.Collections; import org.junit.Before; import org.junit.Test; @@ -36,30 +37,32 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class GenericListWriterTest { private static final InstanceIdentifier - DATA_OBJECT_INSTANCE_IDENTIFIER = InstanceIdentifier.create(IdentifiableDataObject.class); + DATA_OBJECT_ID = InstanceIdentifier.create(IdentifiableDataObject.class); @Mock private ListWriterCustomizer customizer; @Mock private WriteContext ctx; + private GenericListWriter writer; + @Mock + private IdentifiableDataObject before; + @Mock + private DataObjectIdentifier beforeKey; + @Mock + private IdentifiableDataObject after; + @Mock + private DataObjectIdentifier keyAfter; @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); + writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); + when(before.getKey()).thenReturn(beforeKey); + when(after.getKey()).thenReturn(keyAfter); } @Test public void testUpdate() throws Exception { - final GenericListWriter writer = - new GenericListWriter<>(DATA_OBJECT_INSTANCE_IDENTIFIER, customizer); - - final IdentifiableDataObject before = mock(IdentifiableDataObject.class); - final DataObjectIdentifier beforeKey = mock(DataObjectIdentifier.class); - when(before.getKey()).thenReturn(beforeKey); - final IdentifiableDataObject after = mock(IdentifiableDataObject.class); - final DataObjectIdentifier keyAfter = mock(DataObjectIdentifier.class); - when(after.getKey()).thenReturn(keyAfter); - - assertEquals(DATA_OBJECT_INSTANCE_IDENTIFIER, writer.getManagedDataObjectType()); + assertEquals(DATA_OBJECT_ID, writer.getManagedDataObjectType()); final InstanceIdentifier keyedIdBefore = (InstanceIdentifier) InstanceIdentifier.create(Collections @@ -68,16 +71,39 @@ public class GenericListWriterTest { (InstanceIdentifier) InstanceIdentifier.create(Collections .singleton(new InstanceIdentifier.IdentifiableItem<>(IdentifiableDataObject.class, keyAfter))); - writer.update(DATA_OBJECT_INSTANCE_IDENTIFIER, before, after, ctx); + writer.update(DATA_OBJECT_ID, before, after, ctx); verify(customizer).updateCurrentAttributes(keyedIdBefore, before, after, ctx); - writer.update(DATA_OBJECT_INSTANCE_IDENTIFIER, before, null, ctx); + writer.update(DATA_OBJECT_ID, before, null, ctx); verify(customizer).deleteCurrentAttributes(keyedIdBefore, before, ctx); - writer.update(DATA_OBJECT_INSTANCE_IDENTIFIER, null, after, ctx); + writer.update(DATA_OBJECT_ID, null, after, ctx); verify(customizer).writeCurrentAttributes(keyedIdAfter, after, ctx); } private abstract static class IdentifiableDataObject implements DataObject, Identifiable {} private abstract static class DataObjectIdentifier implements Identifier {} + + @Test(expected = WriteFailedException.CreateFailedException.class) + public void testWriteFail() throws Exception { + doThrow(new IllegalStateException("test")).when(customizer).writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); + writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); + writer.writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); + } + + @Test(expected = WriteFailedException.UpdateFailedException.class) + public void testUpdateFail() throws Exception { + doThrow(new IllegalStateException("test")).when(customizer) + .updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); + writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); + writer.updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); + } + + @Test(expected = WriteFailedException.DeleteFailedException.class) + public void testDeleteFail() throws Exception { + doThrow(new IllegalStateException("test")).when(customizer) + .deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); + writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); + writer.deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); + } } \ No newline at end of file diff --git a/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericWriterTest.java b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericWriterTest.java index 827481322..3caea571e 100644 --- a/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericWriterTest.java +++ b/infra/translate-impl/src/test/java/io/fd/honeycomb/translate/impl/write/GenericWriterTest.java @@ -17,11 +17,12 @@ package io.fd.honeycomb.translate.impl.write; import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.verify; import io.fd.honeycomb.translate.spi.write.WriterCustomizer; import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; @@ -32,33 +33,56 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class GenericWriterTest { private static final InstanceIdentifier - DATA_OBJECT_INSTANCE_IDENTIFIER = InstanceIdentifier.create(DataObject.class); + DATA_OBJECT_ID = InstanceIdentifier.create(DataObject.class); @Mock private WriterCustomizer customizer; @Mock private WriteContext ctx; + private GenericWriter writer; + @Mock + private DataObject before; + @Mock + private DataObject after; @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); + writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); } @Test public void testUpdate() throws Exception { - final GenericWriter writer = - new GenericWriter<>(DATA_OBJECT_INSTANCE_IDENTIFIER, customizer); + assertEquals(DATA_OBJECT_ID, writer.getManagedDataObjectType()); + writer.update(DATA_OBJECT_ID, before, after, ctx); + verify(customizer).updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); + + writer.update(DATA_OBJECT_ID, before, null, ctx); + verify(customizer).deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); - final DataObject before = mock(DataObject.class); - final DataObject after = mock(DataObject.class); + writer.update(DATA_OBJECT_ID, null, after, ctx); + verify(customizer).writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); + } - assertEquals(DATA_OBJECT_INSTANCE_IDENTIFIER, writer.getManagedDataObjectType()); - writer.update(DATA_OBJECT_INSTANCE_IDENTIFIER, before, after, ctx); - verify(customizer).updateCurrentAttributes(DATA_OBJECT_INSTANCE_IDENTIFIER, before, after, ctx); + @Test(expected = WriteFailedException.CreateFailedException.class) + public void testWriteFail() throws Exception { + doThrow(new IllegalStateException("test")).when(customizer).writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); + writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); + writer.writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); + } - writer.update(DATA_OBJECT_INSTANCE_IDENTIFIER, before, null, ctx); - verify(customizer).deleteCurrentAttributes(DATA_OBJECT_INSTANCE_IDENTIFIER, before, ctx); + @Test(expected = WriteFailedException.UpdateFailedException.class) + public void testUpdateFail() throws Exception { + doThrow(new IllegalStateException("test")).when(customizer) + .updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); + writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); + writer.updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); + } - writer.update(DATA_OBJECT_INSTANCE_IDENTIFIER, null, after, ctx); - verify(customizer).writeCurrentAttributes(DATA_OBJECT_INSTANCE_IDENTIFIER, after, ctx); + @Test(expected = WriteFailedException.DeleteFailedException.class) + public void testDeleteFail() throws Exception { + doThrow(new IllegalStateException("test")).when(customizer) + .deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); + writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); + writer.deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); } } \ No newline at end of file -- cgit 1.2.3-korg