diff options
Diffstat (limited to 'infra/translate-impl')
4 files changed, 281 insertions, 30 deletions
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<TestingData> + DATA_OBJECT_ID = InstanceIdentifier.create(TestingData.class); + @Mock + private ListReaderCustomizer<TestingData, TestingData.TestingKey, Builder<TestingData>> customizer; + @Mock + private Builder<TestingData> builder; + @Mock + private TestingData data; + @Mock + private ReadContext ctx; + private GenericListReader<TestingData, TestingData.TestingKey, Builder<TestingData>> reader; + private List<TestingData.TestingKey> 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<TestingData.TestingKey> { + + @Override + public Class<? extends DataContainer> getImplementedInterface() { + return DataObject.class; + } + + @Override + public TestingKey getKey() { + return new TestingKey(); + } + + static class TestingKey implements Identifier<TestingData> {} + } +}
\ 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<DataObject> + DATA_OBJECT_ID = InstanceIdentifier.create(DataObject.class); + @Mock + private ReaderCustomizer<DataObject, Builder<DataObject>> customizer; + @Mock + private Builder<DataObject> builder; + @Mock + private DataObject data; + @Mock + private ReadContext ctx; + private GenericReader<DataObject, Builder<DataObject>> 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<IdentifiableDataObject> - DATA_OBJECT_INSTANCE_IDENTIFIER = InstanceIdentifier.create(IdentifiableDataObject.class); + DATA_OBJECT_ID = InstanceIdentifier.create(IdentifiableDataObject.class); @Mock private ListWriterCustomizer<IdentifiableDataObject, DataObjectIdentifier> customizer; @Mock private WriteContext ctx; + private GenericListWriter<IdentifiableDataObject, DataObjectIdentifier> 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<IdentifiableDataObject, DataObjectIdentifier> 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<IdentifiableDataObject> keyedIdBefore = (InstanceIdentifier<IdentifiableDataObject>) InstanceIdentifier.create(Collections @@ -68,16 +71,39 @@ public class GenericListWriterTest { (InstanceIdentifier<IdentifiableDataObject>) 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<DataObjectIdentifier> {} private abstract static class DataObjectIdentifier implements Identifier<IdentifiableDataObject> {} + + @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<DataObject> - DATA_OBJECT_INSTANCE_IDENTIFIER = InstanceIdentifier.create(DataObject.class); + DATA_OBJECT_ID = InstanceIdentifier.create(DataObject.class); @Mock private WriterCustomizer<DataObject> customizer; @Mock private WriteContext ctx; + private GenericWriter<DataObject> 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<DataObject> 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 |