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

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.data.api.schema;
   9
  10 import static org.junit.jupiter.api.Assertions.assertEquals;
  11 import static org.junit.jupiter.api.Assertions.assertNotNull;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.Mockito.doCallRealMethod;
  14 import static org.mockito.Mockito.doReturn;
  15 import static org.mockito.Mockito.mock;
  16
  17 import com.google.common.collect.ImmutableSet;
  18 import java.util.List;
  19 import java.util.Optional;
  20 import org.junit.jupiter.api.Test;
  21 import org.junit.jupiter.api.extension.ExtendWith;
  22 import org.mockito.junit.jupiter.MockitoExtension;
  23 import org.opendaylight.yangtools.yang.common.QName;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  30
  31 @ExtendWith(MockitoExtension.class)
  32 public class NormalizedNodesTest {
  33     @Test
  34     public void testGetDirectChild() {
  35         final var mockedPathArgument = new NodeIdentifier(QName.create("test", "test"));
  36
  37         final var mockedLeafNode = mock(LeafNode.class);
  38         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafNode, mockedPathArgument));
  39
  40         final var mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
  41         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafSetEntryNode, mockedPathArgument));
  42
  43         final var mockedDataContainerNode = mock(DataContainerNode.class);
  44         final var mockedContainerNode = mock(ContainerNode.class);
  45         doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any(PathArgument.class));
  46         doCallRealMethod().when(mockedDataContainerNode).findChildByArg(any(PathArgument.class));
  47
  48         assertEquals(Optional.of(mockedContainerNode),
  49             NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument));
  50
  51         final var mockedMapNode = mock(SystemMapNode.class);
  52         final QName listQName = QName.create("test-ns", "test-list");
  53         final QName listKeyQName = QName.create("test-ns", "test-list-key");
  54         final var nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(listQName, listKeyQName, "str-value");
  55         final var mockedMapEntryNode = mock(MapEntryNode.class);
  56         doReturn(mockedMapEntryNode).when(mockedMapNode).childByArg(any(NodeIdentifierWithPredicates.class));
  57         doCallRealMethod().when(mockedMapNode).findChildByArg(any(NodeIdentifierWithPredicates.class));
  58
  59         assertEquals(Optional.of(mockedMapEntryNode),
  60             NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates));
  61         assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedMapNode, mockedPathArgument));
  62
  63         final SystemLeafSetNode<?> mockedLeafSetNode = mock(SystemLeafSetNode.class);
  64         final QName leafListQName = QName.create("test-ns", "test-leaf-list");
  65         final NodeWithValue<?> nodeWithValue = new NodeWithValue<>(leafListQName, "str-value");
  66         doReturn(mockedLeafSetEntryNode).when(mockedLeafSetNode).childByArg(any(NodeWithValue.class));
  67         doCallRealMethod().when(mockedLeafSetNode).findChildByArg(any(NodeWithValue.class));
  68         assertEquals(Optional.of(mockedLeafSetEntryNode),
  69             NormalizedNodes.getDirectChild(mockedLeafSetNode, nodeWithValue));
  70     }
  71
  72     @Test
  73     public void testFindNode() {
  74         final DataContainerNode mockedDataContainerNode = mock(DataContainerNode.class);
  75         final ContainerNode mockedContainerNode = mock(ContainerNode.class);
  76         final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
  77         doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any(PathArgument.class));
  78         doCallRealMethod().when(mockedDataContainerNode).findChildByArg(any(PathArgument.class));
  79         doReturn(mockedLeafNode).when(mockedContainerNode).childByArg(any(PathArgument.class));
  80         doCallRealMethod().when(mockedContainerNode).findChildByArg(any(PathArgument.class));
  81
  82         final QName node1QName = QName.create("test-ns", "2016-09-16", "node1");
  83         final QName node2Qname = QName.create("test-ns", "2016-09-16", "node2");
  84         final QName node3QName = QName.create("test-ns", "2016-09-16", "node3");
  85         final QName node4Qname = QName.create("test-ns", "2016-09-16", "node4");
  86
  87         final YangInstanceIdentifier rootPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
  88                 new NodeIdentifier(node2Qname));
  89         final YangInstanceIdentifier childPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
  90                 new NodeIdentifier(node2Qname), new NodeIdentifier(node3QName), new NodeIdentifier(node4Qname));
  91
  92         assertEquals(Optional.of(mockedLeafNode),
  93             NormalizedNodes.findNode(rootPath, mockedDataContainerNode, childPath));
  94         assertEquals(Optional.empty(), NormalizedNodes.findNode(childPath, mockedDataContainerNode, rootPath));
  95
  96         final var pathArguments = childPath.relativeTo(rootPath).orElseThrow().getPathArguments()
  97             .toArray(new PathArgument[0]);
  98
  99         assertEquals(Optional.of(mockedLeafNode),
 100             NormalizedNodes.findNode(Optional.of(mockedDataContainerNode), pathArguments));
 101
 102         assertEquals(Optional.of(mockedLeafNode), NormalizedNodes.findNode(mockedDataContainerNode, pathArguments));
 103     }
 104
 105     @Test
 106     public void testToStringTree() {
 107         final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
 108         final QName leafNodeQName = QName.create("test-ns", "2016-09-16", "leaf-node");
 109         final NodeIdentifier leafNodeId = new NodeIdentifier(leafNodeQName);
 110         doReturn(leafNodeId).when(mockedLeafNode).getIdentifier();
 111         doReturn("str-value-1").when(mockedLeafNode).body();
 112
 113         String stringTree = NormalizedNodes.toStringTree(mockedLeafNode);
 114         assertNotNull(stringTree);
 115         assertEquals("leaf-node str-value-1\n", stringTree);
 116
 117         final AugmentationNode mockedAugmentationNode = mock(AugmentationNode.class);
 118         final QName listQName = QName.create("test-ns", "2016-09-16", "list-node");
 119         final AugmentationIdentifier augNodeId = new AugmentationIdentifier(ImmutableSet.of(listQName));
 120         doReturn(augNodeId).when(mockedAugmentationNode).getIdentifier();
 121
 122         final SystemMapNode mockedMapNode = mock(SystemMapNode.class);
 123         final NodeIdentifier listNodeId = new NodeIdentifier(listQName);
 124         doReturn(listNodeId).when(mockedMapNode).getIdentifier();
 125         doReturn(List.of(mockedMapNode)).when(mockedAugmentationNode).body();
 126
 127         final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
 128         final NodeIdentifierWithPredicates listEntryNodeId = NodeIdentifierWithPredicates.of(listQName,
 129                 leafNodeQName, "key-leaf-value");
 130         doReturn(listEntryNodeId).when(mockedMapEntryNode).getIdentifier();
 131         doReturn(List.of(mockedMapEntryNode)).when(mockedMapNode).body();
 132
 133         doReturn(List.of(mockedLeafNode)).when(mockedMapEntryNode).body();
 134
 135         stringTree = NormalizedNodes.toStringTree(mockedAugmentationNode);
 136         assertNotNull(stringTree);
 137         assertEquals("""
 138             augmentation {
 139                 list-node {
 140                     list-node[key-leaf-value] {
 141                         leaf-node str-value-1
 142                     }
 143                 }
 144             }
 145             """, stringTree);
 146     }
 147 }