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

   1 /*
   2  * Copyright (c) 2022 PANTHEON.tech, s.r.o. 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.stream;
   9
  10 import static org.junit.jupiter.api.Assertions.assertEquals;
  11 import static org.mockito.ArgumentMatchers.any;
  12 import static org.mockito.Mockito.doCallRealMethod;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.mock;
  15
  16 import java.io.IOException;
  17 import java.util.List;
  18 import java.util.Optional;
  19 import java.util.Set;
  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.NodeWithValue;
  28 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  29 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  30 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  31 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  32 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  33 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  34 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
  35 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  36 import org.opendaylight.yangtools.yang.model.api.ContainerLike;
  37 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  38 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  40
  41 @ExtendWith(MockitoExtension.class)
  42 public class YangInstanceIdentifierWriterTest {
  43     @Test
  44     public void testYangInstanceIdentifierWriter() throws IOException {
  45         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
  46
  47         final DataNodeContainer root = mock(DataNodeContainer.class);
  48
  49         final ContainerLike containerSchema1 = mock(ContainerLike.class);
  50         final ContainerLike containerSchema2 = mock(ContainerLike.class);
  51         final ContainerLike containerSchema3 = mock(ContainerLike.class);
  52
  53         doReturn(containerSchema1).when(root).dataChildByName(any());
  54         doReturn(containerSchema2).when(containerSchema1).dataChildByName(any());
  55         doReturn(containerSchema3).when(containerSchema2).dataChildByName(any());
  56
  57         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
  58             .node(QName.create("test", "container-1"))
  59             .node(QName.create("test", "container-2"))
  60             .node(QName.create("test", "container-3"))
  61             .build();
  62
  63         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
  64             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
  65                 nnWriter.write(mockedPayload());
  66             }
  67         }
  68
  69         assertEquals("(test)container-1(container)\n"
  70             + "  (test)container-2(container)\n"
  71             + "    (test)container-3(container)\n"
  72             + "      (test)payload-container(container)\n"
  73             + "        (test)payload-leaf(leaf)\n"
  74             + "          (String)=leaf-value\n"
  75             + "        (end)\n"
  76             + "      (end)\n"
  77             + "    (end)\n"
  78             + "  (end)\n"
  79             + "(end)\n", streamWriter.result());
  80     }
  81
  82     @Test
  83     public void testAugmentationIdentifier() throws IOException {
  84         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
  85
  86         final ContainerLike root = mock(ContainerLike.class);
  87         final QName augmented = QName.create("augment-namespace", "augmented-container");
  88         final QName container2Qname = QName.create("augment-namespace", "container-2");
  89
  90         final ContainerLike containerSchema1 = mock(ContainerLike.class);
  91         final AugmentationSchemaNode augmentationSchema = mock(AugmentationSchemaNode.class);
  92         final ContainerLike augmentedContainerSchema = mock(ContainerLike.class);
  93         final ContainerLike containerSchema2 = mock(ContainerLike.class);
  94
  95         doReturn(containerSchema1).when(root).dataChildByName(any());
  96
  97         doReturn(Set.of(augmentationSchema)).when(containerSchema1).getAvailableAugmentations();
  98         doReturn(augmentedContainerSchema).when(augmentationSchema).dataChildByName(augmented);
  99
 100         doReturn(Set.of(augmentedContainerSchema)).when(augmentationSchema).getChildNodes();
 101         doReturn(augmented).when(augmentedContainerSchema).getQName();
 102
 103         doReturn(containerSchema2).when(augmentedContainerSchema).dataChildByName(any());
 104
 105         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 106             .node(QName.create("test", "container-1"))
 107             .node(AugmentationIdentifier.create(Set.of(augmented)))
 108             .node(augmented)
 109             .node(container2Qname)
 110             .build();
 111
 112         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 113             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 114                 nnWriter.write(mockedPayload());
 115             }
 116         }
 117
 118         assertEquals("(test)container-1(container)\n"
 119             + "  AugmentationIdentifier{childNames=[(augment-namespace)augmented-container]}(augmentation)\n"
 120             + "    (augment-namespace)augmented-container(container)\n"
 121             + "      (augment-namespace)container-2(container)\n"
 122             + "        (test)payload-container(container)\n"
 123             + "          (test)payload-leaf(leaf)\n"
 124             + "            (String)=leaf-value\n"
 125             + "          (end)\n"
 126             + "        (end)\n"
 127             + "      (end)\n"
 128             + "    (end)\n"
 129             + "  (end)\n"
 130             + "(end)\n", streamWriter.result());
 131     }
 132
 133     @Test
 134     public void testMapIdentifier() throws IOException {
 135         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 136
 137         final ContainerLike root = mock(ContainerLike.class);
 138         final ListSchemaNode listSchemaNode = mock(ListSchemaNode.class);
 139
 140         final MapEntryNode listEntry = mock(MapEntryNode.class);
 141
 142         final ContainerLike containerSchema1 = mock(ContainerLike.class);
 143         final QName container1Qname = QName.create("test", "container-1");
 144         final QName list1KeyQname = QName.create("test", "list-1-key");
 145         final QName listQname = QName.create("test", "list-1");
 146
 147         doReturn(listQname).when(listSchemaNode).getQName();
 148         doReturn(listSchemaNode).when(root).dataChildByName(any());
 149         doReturn(List.of(list1KeyQname)).when(listSchemaNode).getKeyDefinition();
 150         doReturn(containerSchema1).when(listSchemaNode).dataChildByName(container1Qname);
 151         doReturn("test-list-entry").when(listEntry).toString();
 152
 153         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 154             .node(listQname)
 155             .nodeWithKey(listQname,list1KeyQname, listEntry)
 156             .node(container1Qname)
 157             .build();
 158
 159         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 160             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 161                 nnWriter.write(mockedPayload());
 162             }
 163         }
 164
 165         assertEquals("(test)list-1(key)\n"
 166             + "  (test)list-1[{(test)list-1-key=test-list-entry}][](key)\n"
 167             + "    (test)container-1(container)\n"
 168             + "      (test)payload-container(container)\n"
 169             + "        (test)payload-leaf(leaf)\n"
 170             + "          (String)=leaf-value\n"
 171             + "        (end)\n"
 172             + "      (end)\n"
 173             + "    (end)\n"
 174             + "  (end)\n"
 175             + "(end)\n", streamWriter.result());
 176     }
 177
 178     @Test
 179     public void testChoiceIdentifier() throws IOException {
 180         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 181         final ContainerLike root = mock(ContainerLike.class);
 182         final ChoiceSchemaNode choiceSchemaNode = mock(ChoiceSchemaNode.class);
 183         final CaseSchemaNode caseSchemaNode = mock(CaseSchemaNode.class);
 184         final ContainerLike caseContainer = mock(ContainerLike.class);
 185
 186         final QName choiceQname = QName.create("test", "choice-node");
 187         final QName caseQname = QName.create("test", "container-in-case");
 188
 189         doReturn(choiceSchemaNode).when(root).dataChildByName(choiceQname);
 190         doReturn(Set.of(caseSchemaNode)).when(choiceSchemaNode).getCases();
 191         doCallRealMethod().when(choiceSchemaNode).findDataSchemaChild(any());
 192         doReturn(Optional.of(caseContainer)).when(caseSchemaNode).findDataChildByName(any());
 193
 194         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 195             .node(choiceQname)
 196             .node(caseQname)
 197             .build();
 198
 199         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 200             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 201                 nnWriter.write(mockedPayload());
 202             }
 203         }
 204
 205         assertEquals("(test)choice-node(choice)\n"
 206             + "  (test)container-in-case(container)\n"
 207             + "    (test)payload-container(container)\n"
 208             + "      (test)payload-leaf(leaf)\n"
 209             + "        (String)=leaf-value\n"
 210             + "      (end)\n"
 211             + "    (end)\n"
 212             + "  (end)\n"
 213             + "(end)\n", streamWriter.result());
 214     }
 215
 216     @Test
 217     public void testLeafSetIdentifier() throws IOException {
 218         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 219
 220         final ContainerLike root = mock(ContainerLike.class);
 221         final LeafListSchemaNode leafSetSchema = mock(LeafListSchemaNode.class);
 222
 223         doReturn(leafSetSchema).when(root).dataChildByName(any());
 224
 225         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 226             .node(QName.create("test", "list-list"))
 227             .build();
 228
 229         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 230             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 231                 final QName leafQname = QName.create("test", "leaf");
 232
 233                 final LeafSetEntryNode<?> leafNode = mock(LeafSetEntryNode.class);
 234                 doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafNode).getIdentifier();
 235                 doReturn("test-value").when(leafNode).body();
 236                 nnWriter.write(leafNode);
 237
 238                 final LeafSetEntryNode<?> leafNode2 = mock(LeafSetEntryNode.class);
 239                 doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafNode2).getIdentifier();
 240                 doReturn("test-value-2").when(leafNode2).body();
 241                 nnWriter.write(leafNode2);
 242             }
 243         }
 244
 245         assertEquals("(test)list-list(leaf-list)\n"
 246             + "  (test)leaf(entry)\n"
 247             + "    (String)=test-value\n"
 248             + "  (end)\n"
 249             + "  (test)leaf(entry)\n"
 250             + "    (String)=test-value-2\n"
 251             + "  (end)\n"
 252             + "(end)\n", streamWriter.result());
 253     }
 254
 255     private static NormalizedNode mockedPayload() {
 256         final ContainerNode containerNode = mock(ContainerNode.class);
 257         final LeafNode<?> leafNode = mock(LeafNode.class);
 258
 259         doReturn(new NodeIdentifier(QName.create("test", "payload-container"))).when(containerNode).getIdentifier();
 260         doReturn(Set.of(leafNode)).when(containerNode).body();
 261         doReturn(new NodeIdentifier(QName.create("test", "payload-leaf"))).when(leafNode).getIdentifier();
 262         doReturn("leaf-value").when(leafNode).body();
 263
 264         return containerNode;
 265     }
 266 }