From: Igor Foltin Date: Fri, 12 Aug 2016 13:43:06 +0000 (+0200) Subject: Bug 3899: Milestone: Increase test coverage for Yangtools X-Git-Tag: release/carbon~367 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=387ea1eaaf1ac2482cf3bd761a6caea0f8b92be9;p=yangtools.git Bug 3899: Milestone: Increase test coverage for Yangtools Added tests to DataNodeIteratorTest and SchemaContextProxyTest. Change-Id: If446a0cc0ff415c61b53cf53f96bc49dfaccef08 Signed-off-by: Igor Foltin --- diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java index f5b27059ee..d5a7243f44 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/DataNodeIteratorTest.java @@ -7,15 +7,28 @@ */ package org.opendaylight.yangtools.yang.model.util; +import com.google.common.collect.Sets; +import java.util.Set; import org.junit.Before; import org.junit.Test; +import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; +import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import java.util.Collections; import java.util.NoSuchElementException; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; +import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; public class DataNodeIteratorTest { @@ -52,4 +65,59 @@ public class DataNodeIteratorTest { assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allGroupings()); assertEquals("Should be empty list", Collections.EMPTY_LIST, dataNodeIterator.allLists()); } + + @Test + public void testTraversal() { + final Module mockedModule = mock(Module.class); + + final ContainerSchemaNode mockedAugmentingContainer = mock(ContainerSchemaNode.class); + doReturn(true).when(mockedAugmentingContainer).isAugmenting(); + + final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class); + + final ListSchemaNode mockedList = mock(ListSchemaNode.class); + + final ChoiceSchemaNode mockedChoice = mock(ChoiceSchemaNode.class); + final ChoiceCaseNode mockedCase1 = mock(ChoiceCaseNode.class); + final ChoiceCaseNode mockedCase2 = mock(ChoiceCaseNode.class); + final Set cases = Sets.newHashSet(mockedCase1, mockedCase2); + doReturn(cases).when(mockedChoice).getCases(); + + final Set childNodes = Sets.newHashSet(mockedAugmentingContainer, mockedContainer, mockedList, mockedChoice); + doReturn(childNodes).when(mockedModule).getChildNodes(); + + final NotificationDefinition mockedNotification = mock(NotificationDefinition.class); + final ContainerSchemaNode mockedContainerInNotification = mock(ContainerSchemaNode.class); + final Set notificationChildNodes = Sets.newHashSet(mockedContainerInNotification); + doReturn(notificationChildNodes).when(mockedNotification).getChildNodes(); + final Set notifications = Sets.newHashSet(mockedNotification); + + doReturn(notifications).when(mockedModule).getNotifications(); + + final RpcDefinition mockedRpc = mock(RpcDefinition.class); + final ContainerSchemaNode mockedContainerInRpcInput = mock(ContainerSchemaNode.class); + final ListSchemaNode mockedListInRpcInputContainer = mock(ListSchemaNode.class); + final Set rpcInputChildNodes = Sets.newHashSet(mockedListInRpcInputContainer); + doReturn(rpcInputChildNodes).when(mockedContainerInRpcInput).getChildNodes(); + doReturn(mockedContainerInRpcInput).when(mockedRpc).getInput(); + final Set rpcs = Sets.newHashSet(mockedRpc); + + doReturn(rpcs).when(mockedModule).getRpcs(); + + final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class); + final Set groupings = Sets.newHashSet(mockedGrouping); + + doReturn(groupings).when(mockedModule).getGroupings(); + + final DataNodeIterator dataNodeIterator = new DataNodeIterator(mockedModule); + assertFalse(dataNodeIterator.allContainers().contains(mockedAugmentingContainer)); + assertTrue(dataNodeIterator.allContainers().contains(mockedContainer)); + assertTrue(dataNodeIterator.allLists().contains(mockedList)); + assertTrue(dataNodeIterator.allChoices().contains(mockedChoice)); + assertTrue(dataNodeIterator.allChoices().get(0).getCases().contains(mockedCase1)); + assertTrue(dataNodeIterator.allChoices().get(0).getCases().contains(mockedCase2)); + assertTrue(dataNodeIterator.allContainers().contains(mockedContainerInNotification)); + assertTrue(dataNodeIterator.allLists().contains(mockedListInRpcInputContainer)); + assertTrue(dataNodeIterator.allGroupings().contains(mockedGrouping)); + } } \ No newline at end of file diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java index be3ce52eac..52398a7142 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java @@ -9,9 +9,11 @@ package org.opendaylight.yangtools.yang.model.util; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; +import com.google.common.collect.Lists; import com.google.common.collect.Sets; import java.net.URI; import java.net.URISyntaxException; @@ -19,15 +21,25 @@ import java.text.ParseException; import java.util.Arrays; import java.util.Date; import java.util.HashSet; +import java.util.List; import java.util.Set; import org.junit.BeforeClass; import org.junit.Test; import org.opendaylight.yangtools.concepts.SemVer; +import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition; +import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.ModuleImport; +import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; +import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.TypeDefinition; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId; public class SchemaContextProxyTest { @@ -415,6 +427,142 @@ public class SchemaContextProxyTest { assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4); } + @Test + public void testGetDataDefinitions() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class); + final Set childNodes = Sets.newHashSet(mockedContainer); + doReturn(childNodes).when(moduleConfig).getChildNodes(); + + final Set dataDefinitions = filteringSchemaContextProxy.getDataDefinitions(); + assertTrue(dataDefinitions.contains(mockedContainer)); + } + + @Test + public void testGetNotifications() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final NotificationDefinition mockedNotification = mock(NotificationDefinition.class); + final Set notifications = Sets.newHashSet(mockedNotification); + doReturn(notifications).when(moduleConfig).getNotifications(); + + final Set schemaContextProxyNotifications = filteringSchemaContextProxy.getNotifications(); + assertTrue(schemaContextProxyNotifications.contains(mockedNotification)); + } + + @Test + public void testGetOperations() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final RpcDefinition mockedRpc = mock(RpcDefinition.class); + final Set rpcs = Sets.newHashSet(mockedRpc); + doReturn(rpcs).when(moduleConfig).getRpcs(); + + final Set operations = filteringSchemaContextProxy.getOperations(); + assertTrue(operations.contains(mockedRpc)); + } + + @Test + public void testGetExtensions() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class); + final List extensions = Lists.newArrayList(mockedExtension); + doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes(); + + final Set schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions(); + assertTrue(schemaContextProxyExtensions.contains(mockedExtension)); + } + + @Test + public void testGetUnknownSchemaNodes() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class); + final List unknownSchemaNodes = Lists.newArrayList(mockedUnknownSchemaNode); + doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes(); + + final List schemaContextProxyUnknownSchemaNodes = + filteringSchemaContextProxy.getUnknownSchemaNodes(); + assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode)); + } + + @Test + public void testGetTypeDefinitions() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final TypeDefinition mockedTypeDefinition = mock(TypeDefinition.class); + final Set> typeDefinitions = Sets.newHashSet(mockedTypeDefinition); + doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions(); + + final Set> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy.getTypeDefinitions(); + assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition)); + } + + @Test + public void testGetChildNodes() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class); + final Set childNodes = Sets.newHashSet(mockedContainer); + doReturn(childNodes).when(moduleConfig).getChildNodes(); + + final Set schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes(); + assertTrue(schemaContextProxyChildNodes.contains(mockedContainer)); + } + + @Test + public void testGetGroupings() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class); + final Set groupings = Sets.newHashSet(mockedGrouping); + doReturn(groupings).when(moduleConfig).getGroupings(); + + final Set schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings(); + assertTrue(schemaContextProxyGroupings.contains(mockedGrouping)); + } + + @Test + public void testGetDataChildByName() { + final Module moduleConfig = mockModule(CONFIG_NAME); + final SchemaContext schemaContext = mockSchema(moduleConfig); + final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, + Sets.newHashSet(), moduleConfig); + + final QName qName = QName.create("config-namespace", "2016-08-11", "cont"); + final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class); + doReturn(mockedContainer).when(moduleConfig).getDataChildByName(any(QName.class)); + + final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qName); + assertTrue(dataSchemaNode instanceof ContainerSchemaNode); + } + private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy, final Module... expected) { Set modSet = Sets.newHashSet();