DataContainerChild is identified by NodeIdentifier

[yangtools.git] / data / yang-data-api / src / test / java / org / opendaylight / yangtools / yang / data / api / schema / NormalizedNodesTest.java

diff --git a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java
index 5cea4b8386d30b1bc0f70002fa6e9cf7ef9c67a5..f1253cd5b17116582cc5846967031c0749668e52 100644 (file)
--- a/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java
+++ b/data/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodesTest.java
@@ -10,11 +10,9 @@ package org.opendaylight.yangtools.yang.data.api.schema;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 
-import com.google.common.collect.ImmutableSet;
 import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
@@ -22,7 +20,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
@@ -32,41 +29,38 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgum
 public class NormalizedNodesTest {
     @Test
     public void testGetDirectChild() {
-        final PathArgument mockedPathArgument = mock(PathArgument.class);
+        final var mockedPathArgument = new NodeIdentifier(QName.create("test", "test"));
 
-        final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
+        final var mockedLeafNode = mock(LeafNode.class);
         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafNode, mockedPathArgument));
 
-        final LeafSetEntryNode<?> mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
+        final var mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafSetEntryNode, mockedPathArgument));
 
-        final DataContainerNode mockedDataContainerNode = mock(DataContainerNode.class);
-        final ContainerNode mockedContainerNode = mock(ContainerNode.class);
-        doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any(PathArgument.class));
-        doCallRealMethod().when(mockedDataContainerNode).findChildByArg(any(PathArgument.class));
+        final var mockedDataContainerNode = mock(DataContainerNode.class);
+        final var mockedContainerNode = mock(ContainerNode.class);
+        doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any());
 
-        assertEquals(mockedContainerNode, NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument)
-                .get());
+        assertEquals(Optional.of(mockedContainerNode),
+            NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument));
 
-        final SystemMapNode mockedMapNode = mock(SystemMapNode.class);
+        final var mockedMapNode = mock(SystemMapNode.class);
         final QName listQName = QName.create("test-ns", "test-list");
         final QName listKeyQName = QName.create("test-ns", "test-list-key");
-        final NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
-                NodeIdentifierWithPredicates.of(listQName, listKeyQName, "str-value");
-        final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
+        final var nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(listQName, listKeyQName, "str-value");
+        final var mockedMapEntryNode = mock(MapEntryNode.class);
         doReturn(mockedMapEntryNode).when(mockedMapNode).childByArg(any(NodeIdentifierWithPredicates.class));
-        doCallRealMethod().when(mockedMapNode).findChildByArg(any(NodeIdentifierWithPredicates.class));
 
-        assertEquals(mockedMapEntryNode, NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates)
-                .get());
+        assertEquals(Optional.of(mockedMapEntryNode),
+            NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates));
         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedMapNode, mockedPathArgument));
 
         final SystemLeafSetNode<?> mockedLeafSetNode = mock(SystemLeafSetNode.class);
         final QName leafListQName = QName.create("test-ns", "test-leaf-list");
         final NodeWithValue<?> nodeWithValue = new NodeWithValue<>(leafListQName, "str-value");
         doReturn(mockedLeafSetEntryNode).when(mockedLeafSetNode).childByArg(any(NodeWithValue.class));
-        doCallRealMethod().when(mockedLeafSetNode).findChildByArg(any(NodeWithValue.class));
-        assertEquals(mockedLeafSetEntryNode, NormalizedNodes.getDirectChild(mockedLeafSetNode, nodeWithValue).get());
+        assertEquals(Optional.of(mockedLeafSetEntryNode),
+            NormalizedNodes.getDirectChild(mockedLeafSetNode, nodeWithValue));
     }
 
     @Test
@@ -74,10 +68,8 @@ public class NormalizedNodesTest {
         final DataContainerNode mockedDataContainerNode = mock(DataContainerNode.class);
         final ContainerNode mockedContainerNode = mock(ContainerNode.class);
         final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
-        doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any(PathArgument.class));
-        doCallRealMethod().when(mockedDataContainerNode).findChildByArg(any(PathArgument.class));
-        doReturn(mockedLeafNode).when(mockedContainerNode).childByArg(any(PathArgument.class));
-        doCallRealMethod().when(mockedContainerNode).findChildByArg(any(PathArgument.class));
+        doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any());
+        doReturn(mockedLeafNode).when(mockedContainerNode).childByArg(any());
 
         final QName node1QName = QName.create("test-ns", "2016-09-16", "node1");
         final QName node2Qname = QName.create("test-ns", "2016-09-16", "node2");
@@ -89,16 +81,17 @@ public class NormalizedNodesTest {
         final YangInstanceIdentifier childPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
                 new NodeIdentifier(node2Qname), new NodeIdentifier(node3QName), new NodeIdentifier(node4Qname));
 
-        assertEquals(mockedLeafNode, NormalizedNodes.findNode(rootPath, mockedDataContainerNode, childPath).get());
+        assertEquals(Optional.of(mockedLeafNode),
+            NormalizedNodes.findNode(rootPath, mockedDataContainerNode, childPath));
         assertEquals(Optional.empty(), NormalizedNodes.findNode(childPath, mockedDataContainerNode, rootPath));
 
-        final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
-        final PathArgument[] pathArguments = relativePath.get().getPathArguments().toArray(new PathArgument[2]);
+        final var pathArguments = childPath.relativeTo(rootPath).orElseThrow().getPathArguments()
+            .toArray(new PathArgument[0]);
 
-        assertEquals(mockedLeafNode, NormalizedNodes.findNode(Optional.of(mockedDataContainerNode),
-                pathArguments).get());
+        assertEquals(Optional.of(mockedLeafNode),
+            NormalizedNodes.findNode(Optional.of(mockedDataContainerNode), pathArguments));
 
-        assertEquals(mockedLeafNode, NormalizedNodes.findNode(mockedDataContainerNode, pathArguments).get());
+        assertEquals(Optional.of(mockedLeafNode), NormalizedNodes.findNode(mockedDataContainerNode, pathArguments));
     }
 
     @Test
@@ -113,15 +106,11 @@ public class NormalizedNodesTest {
         assertNotNull(stringTree);
         assertEquals("leaf-node str-value-1\n", stringTree);
 
-        final AugmentationNode mockedAugmentationNode = mock(AugmentationNode.class);
         final QName listQName = QName.create("test-ns", "2016-09-16", "list-node");
-        final AugmentationIdentifier augNodeId = new AugmentationIdentifier(ImmutableSet.of(listQName));
-        doReturn(augNodeId).when(mockedAugmentationNode).getIdentifier();
 
         final SystemMapNode mockedMapNode = mock(SystemMapNode.class);
         final NodeIdentifier listNodeId = new NodeIdentifier(listQName);
         doReturn(listNodeId).when(mockedMapNode).getIdentifier();
-        doReturn(List.of(mockedMapNode)).when(mockedAugmentationNode).body();
 
         final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
         final NodeIdentifierWithPredicates listEntryNodeId = NodeIdentifierWithPredicates.of(listQName,
@@ -131,14 +120,12 @@ public class NormalizedNodesTest {
 
         doReturn(List.of(mockedLeafNode)).when(mockedMapEntryNode).body();
 
-        stringTree = NormalizedNodes.toStringTree(mockedAugmentationNode);
+        stringTree = NormalizedNodes.toStringTree(mockedMapNode);
         assertNotNull(stringTree);
         assertEquals("""
-            augmentation {
-                list-node {
-                    list-node[key-leaf-value] {
-                        leaf-node str-value-1
-                    }
+            list-node {
+                list-node[key-leaf-value] {
+                    leaf-node str-value-1
                 }
             }
             """, stringTree);