Bug 3899: Milestone: Increase test coverage for Yangtools

Added tests to DataNodeIteratorTest and SchemaContextProxyTest.

Change-Id: If446a0cc0ff415c61b53cf53f96bc49dfaccef08
Signed-off-by: Igor Foltin <ifoltin@cisco.com>

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 f5b27059eee979b39c9182bae72bbd858d96b48c..d5a7243f44f94174ddf9ee72a34857394af528f1 100644 (file)
--- 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<ChoiceCaseNode> cases = Sets.newHashSet(mockedCase1, mockedCase2);
+        doReturn(cases).when(mockedChoice).getCases();
+
+        final Set<DataSchemaNode> 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<DataSchemaNode> notificationChildNodes = Sets.newHashSet(mockedContainerInNotification);
+        doReturn(notificationChildNodes).when(mockedNotification).getChildNodes();
+        final Set<NotificationDefinition> 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<DataSchemaNode> rpcInputChildNodes = Sets.newHashSet(mockedListInRpcInputContainer);
+        doReturn(rpcInputChildNodes).when(mockedContainerInRpcInput).getChildNodes();
+        doReturn(mockedContainerInRpcInput).when(mockedRpc).getInput();
+        final Set<RpcDefinition> rpcs = Sets.newHashSet(mockedRpc);
+
+        doReturn(rpcs).when(mockedModule).getRpcs();
+
+        final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
+        final Set<GroupingDefinition> 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 be3ce52eac18b9b8c8a9b905bd2ec556456f3c99..52398a71428f82b21c6395d31ea88b299fed0a7c 100644 (file)
--- 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<DataSchemaNode> childNodes = Sets.newHashSet(mockedContainer);
+        doReturn(childNodes).when(moduleConfig).getChildNodes();
+
+        final Set<DataSchemaNode> 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<NotificationDefinition> notifications = Sets.newHashSet(mockedNotification);
+        doReturn(notifications).when(moduleConfig).getNotifications();
+
+        final Set<NotificationDefinition> 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<RpcDefinition> rpcs = Sets.newHashSet(mockedRpc);
+        doReturn(rpcs).when(moduleConfig).getRpcs();
+
+        final Set<RpcDefinition> 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<ExtensionDefinition> extensions = Lists.newArrayList(mockedExtension);
+        doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
+
+        final Set<ExtensionDefinition> 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<UnknownSchemaNode> unknownSchemaNodes = Lists.newArrayList(mockedUnknownSchemaNode);
+        doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
+
+        final List<UnknownSchemaNode> 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<TypeDefinition<?>> typeDefinitions = Sets.newHashSet(mockedTypeDefinition);
+        doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
+
+        final Set<TypeDefinition<?>> 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<DataSchemaNode> childNodes = Sets.newHashSet(mockedContainer);
+        doReturn(childNodes).when(moduleConfig).getChildNodes();
+
+        final Set<DataSchemaNode> 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<GroupingDefinition> groupings = Sets.newHashSet(mockedGrouping);
+        doReturn(groupings).when(moduleConfig).getGroupings();
+
+        final Set<GroupingDefinition> 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<Module> modSet = Sets.newHashSet();