From b589b5bb6fc4b88f74710010782b155c80433740 Mon Sep 17 00:00:00 2001 From: Maros Marsalek Date: Wed, 7 Sep 2016 17:15:09 +0200 Subject: HONEYCOMB-194 Increase data-impl coverage to 87% Change-Id: I1bd6d6ad2e8d35322346aa658e74413ce2d889f0 Signed-off-by: Maros Marsalek --- .../io/fd/honeycomb/data/impl/DataBrokerTest.java | 71 +++++++++++++++++++++- .../data/impl/PersistingDataTreeAdapterTest.java | 68 +++++++++++++++++++++ .../data/impl/ReadableDataTreeDelegatorTest.java | 27 ++++++++ 3 files changed, 165 insertions(+), 1 deletion(-) (limited to 'infra/data-impl/src/test') diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java index 08cb3320f..f1bc3105a 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/DataBrokerTest.java @@ -107,5 +107,74 @@ public class DataBrokerTest { assertTrue(supportedExtensions.isEmpty()); } - + public static class DataBrokerForContextTest { + + @Mock + private ModifiableDataManager contextDataTree; + @Mock + private DataModification contextSnapshot; + private DataBroker broker; + + @Before + public void setUp() { + initMocks(this); + when(contextDataTree.newModification()).thenReturn(contextSnapshot); + broker = DataBroker.create(contextDataTree); + } + + @Test + public void testNewReadWriteTransaction() { + final DOMDataReadWriteTransaction readWriteTx = broker.newReadWriteTransaction(); + final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); + readWriteTx.read(LogicalDatastoreType.OPERATIONAL, path); + + verify(contextSnapshot).read(path); + verify(contextDataTree).newModification(); + } + + @Test + public void testNewWriteOnlyTransaction() { + broker.newWriteOnlyTransaction(); + verify(contextDataTree).newModification(); + } + + @Test + public void testNewReadOnlyTransaction() { + final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction(); + final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); + readTx.read(LogicalDatastoreType.OPERATIONAL, path); + + // operational data are read directly from data tree + verify(contextDataTree).read(path); + } + + @Test(expected = IllegalArgumentException.class) + public void testReadConfig() { + final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction(); + + final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); + readTx.read(LogicalDatastoreType.CONFIGURATION, path); + } + + @Test(expected = UnsupportedOperationException.class) + public void testRegisterDataChangeListener() { + final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); + final DOMDataChangeListener listener = mock(DOMDataChangeListener.class); + broker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, path, listener, + AsyncDataBroker.DataChangeScope.BASE); + } + + @Test(expected = UnsupportedOperationException.class) + public void testCreateTransactionChain() { + final TransactionChainListener listener = mock(TransactionChainListener.class); + broker.createTransactionChain(listener); + } + + @Test + public void testGetSupportedExtensions() { + final Map, DOMDataBrokerExtension> supportedExtensions = + broker.getSupportedExtensions(); + assertTrue(supportedExtensions.isEmpty()); + } + } } \ No newline at end of file diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/PersistingDataTreeAdapterTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/PersistingDataTreeAdapterTest.java index 305166421..8430073ac 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/PersistingDataTreeAdapterTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/PersistingDataTreeAdapterTest.java @@ -16,12 +16,17 @@ package io.fd.honeycomb.data.impl; +import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; +import com.google.common.base.Optional; +import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import org.junit.Before; @@ -29,9 +34,11 @@ import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.opendaylight.controller.sal.core.api.model.SchemaService; +import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot; +import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; public class PersistingDataTreeAdapterTest { @@ -41,6 +48,8 @@ public class PersistingDataTreeAdapterTest { private SchemaService schemaService; @Mock private DataTreeSnapshot snapshot; + @Mock + private PersistingDataTreeAdapter.JsonPersister persister; private Path tmpPersistFile; @@ -49,6 +58,8 @@ public class PersistingDataTreeAdapterTest { @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); + doReturn(snapshot).when(delegatingDataTree).takeSnapshot(); + doNothing().when(persister).persistCurrentData(any(Optional.class)); tmpPersistFile = Files.createTempFile("testing-hc-persistence", "json"); persistingDataTreeAdapter = new PersistingDataTreeAdapter(delegatingDataTree, schemaService, tmpPersistFile); } @@ -66,4 +77,61 @@ public class PersistingDataTreeAdapterTest { } } + @Test + public void testPersist() throws Exception { + persistingDataTreeAdapter = new PersistingDataTreeAdapter(delegatingDataTree, persister); + persistingDataTreeAdapter.commit(null); + verify(delegatingDataTree).takeSnapshot(); + verify(persister).persistCurrentData(any(Optional.class)); + } + + @Test + public void testTakeSnapshot() throws Exception { + persistingDataTreeAdapter.takeSnapshot(); + verify(delegatingDataTree).takeSnapshot(); + } + + @Test + public void testSetSchema() throws Exception { + persistingDataTreeAdapter.setSchemaContext(null); + verify(delegatingDataTree).setSchemaContext(null); + } + + @Test + public void testValidate() throws Exception { + persistingDataTreeAdapter.validate(null); + verify(delegatingDataTree).validate(null); + } + + @Test + public void testPrepare() throws Exception { + persistingDataTreeAdapter.prepare(null); + verify(delegatingDataTree).prepare(null); + } + + @Test + public void testGetRootPath() throws Exception { + persistingDataTreeAdapter.getRootPath(); + verify(delegatingDataTree).getRootPath(); + } + + @Test(expected = IllegalStateException.class) + public void testPersistFailure() throws Exception { + doThrow(IOException.class).when(schemaService).getGlobalContext(); + final PersistingDataTreeAdapter.JsonPersister jsonPersister = + new PersistingDataTreeAdapter.JsonPersister(tmpPersistFile, schemaService); + // Nothing + jsonPersister.persistCurrentData(Optional.absent()); + // Exception + jsonPersister.persistCurrentData(Optional.of(ImmutableNodes.leafNode(QName.create("namespace", "leaf"), "value"))); + } + + @Test + public void testPersisterCreateFile() throws Exception { + // Delete to test file creation + Files.delete(tmpPersistFile); + final PersistingDataTreeAdapter.JsonPersister jsonPersister = + new PersistingDataTreeAdapter.JsonPersister(tmpPersistFile, schemaService); + assertTrue(Files.exists(tmpPersistFile)); + } } \ No newline at end of file diff --git a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java index 2b4cc2a06..e795fbe44 100644 --- a/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java +++ b/infra/data-impl/src/test/java/io/fd/honeycomb/data/impl/ReadableDataTreeDelegatorTest.java @@ -16,6 +16,7 @@ package io.fd.honeycomb.data.impl; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -32,13 +33,16 @@ import static org.mockito.MockitoAnnotations.initMocks; import com.google.common.base.Optional; import com.google.common.collect.Iterables; import com.google.common.collect.LinkedListMultimap; +import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import com.google.common.util.concurrent.CheckedFuture; import com.google.common.util.concurrent.Futures; import io.fd.honeycomb.translate.read.ReadContext; import io.fd.honeycomb.translate.read.registry.ReaderRegistry; import java.util.Collections; +import java.util.List; import java.util.Map; +import java.util.stream.Collectors; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; @@ -48,6 +52,7 @@ import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeSerializer; +import org.opendaylight.yangtools.util.UnmodifiableCollection; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.QName; @@ -55,7 +60,9 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; public class ReadableDataTreeDelegatorTest { @@ -189,4 +196,24 @@ public class ReadableDataTreeDelegatorTest { assertEquals(SchemaContext.NAME, rootNode.getIdentifier().getNodeType()); assertEquals(vppStateContainer, Iterables.getOnlyElement(rootNode.getValue())); } + + + @Test + public void testWrapMixin() throws Exception { + final QName nodeQName = QName.create("namespace", "node"); + final QName keyQName = QName.create("namespace", "key"); + final List> mapNodes = Lists.newArrayList("one", "two", "three").stream() + .map(value -> ImmutableNodes.mapEntry(nodeQName, keyQName, value)) + .collect(Collectors.toList()); + final ListSchemaNode listSchema = mock(ListSchemaNode.class); + doReturn(Collections.singletonList(keyQName)).when(listSchema).getKeyDefinition(); + doReturn(true).when(listSchema).isUserOrdered(); + doReturn(nodeQName).when(listSchema).getQName(); + + final DataContainerChild dataContainerChild = + ReadableDataTreeDelegator.wrapListIntoMixinNode(mapNodes, listSchema); + + // asserting as arrays, since UnmodifiableCollection has no equals + assertArrayEquals(mapNodes.toArray(), ((UnmodifiableCollection) dataContainerChild.getValue()).toArray()); + } } \ No newline at end of file -- cgit 1.2.3-korg