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("""
  70             (test)container-1(container)
  71               (test)container-2(container)
  72                 (test)container-3(container)
  73                   (test)payload-container(container)
  74                     (test)payload-leaf(leaf)
  75                       (String)=leaf-value
  76                     (end)
  77                   (end)
  78                 (end)
  79               (end)
  80             (end)
  81             """, streamWriter.result());
  82     }
  83
  84     @Test
  85     public void testAugmentationIdentifier() throws IOException {
  86         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
  87
  88         final ContainerLike root = mock(ContainerLike.class);
  89         final QName augmented = QName.create("augment-namespace", "augmented-container");
  90         final QName container2Qname = QName.create("augment-namespace", "container-2");
  91
  92         final ContainerLike containerSchema1 = mock(ContainerLike.class);
  93         final AugmentationSchemaNode augmentationSchema = mock(AugmentationSchemaNode.class);
  94         final ContainerLike augmentedContainerSchema = mock(ContainerLike.class);
  95         final ContainerLike containerSchema2 = mock(ContainerLike.class);
  96
  97         doReturn(containerSchema1).when(root).dataChildByName(any());
  98
  99         doReturn(Set.of(augmentationSchema)).when(containerSchema1).getAvailableAugmentations();
 100         doReturn(augmentedContainerSchema).when(augmentationSchema).dataChildByName(augmented);
 101
 102         doReturn(Set.of(augmentedContainerSchema)).when(augmentationSchema).getChildNodes();
 103         doReturn(augmented).when(augmentedContainerSchema).getQName();
 104
 105         doReturn(containerSchema2).when(augmentedContainerSchema).dataChildByName(any());
 106
 107         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 108             .node(QName.create("test", "container-1"))
 109             .node(AugmentationIdentifier.create(Set.of(augmented)))
 110             .node(augmented)
 111             .node(container2Qname)
 112             .build();
 113
 114         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 115             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 116                 nnWriter.write(mockedPayload());
 117             }
 118         }
 119
 120         assertEquals("""
 121             (test)container-1(container)
 122               AugmentationIdentifier{childNames=[(augment-namespace)augmented-container]}(augmentation)
 123                 (augment-namespace)augmented-container(container)
 124                   (augment-namespace)container-2(container)
 125                     (test)payload-container(container)
 126                       (test)payload-leaf(leaf)
 127                         (String)=leaf-value
 128                       (end)
 129                     (end)
 130                   (end)
 131                 (end)
 132               (end)
 133             (end)
 134             """, streamWriter.result());
 135     }
 136
 137     @Test
 138     public void testMapIdentifier() throws IOException {
 139         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 140
 141         final ContainerLike root = mock(ContainerLike.class);
 142         final ListSchemaNode listSchemaNode = mock(ListSchemaNode.class);
 143
 144         final MapEntryNode listEntry = mock(MapEntryNode.class);
 145
 146         final ContainerLike containerSchema1 = mock(ContainerLike.class);
 147         final QName container1Qname = QName.create("test", "container-1");
 148         final QName list1KeyQname = QName.create("test", "list-1-key");
 149         final QName listQname = QName.create("test", "list-1");
 150
 151         doReturn(listQname).when(listSchemaNode).getQName();
 152         doReturn(listSchemaNode).when(root).dataChildByName(any());
 153         doReturn(List.of(list1KeyQname)).when(listSchemaNode).getKeyDefinition();
 154         doReturn(containerSchema1).when(listSchemaNode).dataChildByName(container1Qname);
 155         doReturn("test-list-entry").when(listEntry).toString();
 156
 157         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 158             .node(listQname)
 159             .nodeWithKey(listQname,list1KeyQname, listEntry)
 160             .node(container1Qname)
 161             .build();
 162
 163         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 164             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 165                 nnWriter.write(mockedPayload());
 166             }
 167         }
 168
 169         assertEquals("""
 170             (test)list-1(key)
 171               (test)list-1[{(test)list-1-key=test-list-entry}][](key)
 172                 (test)container-1(container)
 173                   (test)payload-container(container)
 174                     (test)payload-leaf(leaf)
 175                       (String)=leaf-value
 176                     (end)
 177                   (end)
 178                 (end)
 179               (end)
 180             (end)
 181             """, streamWriter.result());
 182     }
 183
 184     @Test
 185     public void testChoiceIdentifier() throws IOException {
 186         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 187         final ContainerLike root = mock(ContainerLike.class);
 188         final ChoiceSchemaNode choiceSchemaNode = mock(ChoiceSchemaNode.class);
 189         final CaseSchemaNode caseSchemaNode = mock(CaseSchemaNode.class);
 190         final ContainerLike caseContainer = mock(ContainerLike.class);
 191
 192         final QName choiceQname = QName.create("test", "choice-node");
 193         final QName caseQname = QName.create("test", "container-in-case");
 194
 195         doReturn(choiceSchemaNode).when(root).dataChildByName(choiceQname);
 196         doReturn(Set.of(caseSchemaNode)).when(choiceSchemaNode).getCases();
 197         doCallRealMethod().when(choiceSchemaNode).findDataSchemaChild(any());
 198         doReturn(Optional.of(caseContainer)).when(caseSchemaNode).findDataChildByName(any());
 199
 200         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 201             .node(choiceQname)
 202             .node(caseQname)
 203             .build();
 204
 205         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 206             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 207                 nnWriter.write(mockedPayload());
 208             }
 209         }
 210
 211         assertEquals("""
 212             (test)choice-node(choice)
 213               (test)container-in-case(container)
 214                 (test)payload-container(container)
 215                   (test)payload-leaf(leaf)
 216                     (String)=leaf-value
 217                   (end)
 218                 (end)
 219               (end)
 220             (end)
 221             """, streamWriter.result());
 222     }
 223
 224     @Test
 225     public void testLeafSetIdentifier() throws IOException {
 226         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 227
 228         final ContainerLike root = mock(ContainerLike.class);
 229         final LeafListSchemaNode leafSetSchema = mock(LeafListSchemaNode.class);
 230
 231         doReturn(leafSetSchema).when(root).dataChildByName(any());
 232
 233         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 234             .node(QName.create("test", "list-list"))
 235             .build();
 236
 237         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, root, path)) {
 238             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 239                 final QName leafQname = QName.create("test", "leaf");
 240
 241                 final LeafSetEntryNode<?> leafNode = mock(LeafSetEntryNode.class);
 242                 doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafNode).getIdentifier();
 243                 doReturn("test-value").when(leafNode).body();
 244                 nnWriter.write(leafNode);
 245
 246                 final LeafSetEntryNode<?> leafNode2 = mock(LeafSetEntryNode.class);
 247                 doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafNode2).getIdentifier();
 248                 doReturn("test-value-2").when(leafNode2).body();
 249                 nnWriter.write(leafNode2);
 250             }
 251         }
 252
 253         assertEquals("""
 254             (test)list-list(leaf-list)
 255               (test)leaf(entry)
 256                 (String)=test-value
 257               (end)
 258               (test)leaf(entry)
 259                 (String)=test-value-2
 260               (end)
 261             (end)
 262             """, streamWriter.result());
 263     }
 264
 265     private static NormalizedNode mockedPayload() {
 266         final ContainerNode containerNode = mock(ContainerNode.class);
 267         final LeafNode<?> leafNode = mock(LeafNode.class);
 268
 269         doReturn(new NodeIdentifier(QName.create("test", "payload-container"))).when(containerNode).getIdentifier();
 270         doReturn(Set.of(leafNode)).when(containerNode).body();
 271         doReturn(new NodeIdentifier(QName.create("test", "payload-leaf"))).when(leafNode).getIdentifier();
 272         doReturn("leaf-value").when(leafNode).body();
 273
 274         return containerNode;
 275     }
 276 }