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.Mockito.doReturn;
  12 import static org.mockito.Mockito.mock;
  13
  14 import java.io.IOException;
  15 import java.util.Set;
  16 import org.junit.jupiter.api.BeforeAll;
  17 import org.junit.jupiter.api.Test;
  18 import org.junit.jupiter.api.extension.ExtendWith;
  19 import org.mockito.junit.jupiter.MockitoExtension;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  25 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  26 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  27 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  28 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  29 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  30 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  31
  32 @ExtendWith(MockitoExtension.class)
  33 public class YangInstanceIdentifierWriterTest {
  34     private static EffectiveModelContext CONTEXT;
  35
  36     @BeforeAll
  37     public static void beforeAll() {
  38         CONTEXT = YangParserTestUtils.parseYangResourceDirectory("/YT1392");
  39     }
  40
  41     @Test
  42     public void testYangInstanceIdentifierWriter() throws IOException {
  43         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
  44
  45         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
  46             .node(QName.create("test", "container-1"))
  47             .node(QName.create("test", "container-2"))
  48             .node(QName.create("test", "container-3"))
  49             .build();
  50
  51         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
  52             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
  53                 nnWriter.write(mockedPayload());
  54             }
  55         }
  56
  57         assertEquals("""
  58             (test)container-1(container)
  59               (test)container-2(container)
  60                 (test)container-3(container)
  61                   (test)payload-container(container)
  62                     (test)payload-leaf(leaf)
  63                       (String)=leaf-value
  64                     (end)
  65                   (end)
  66                 (end)
  67               (end)
  68             (end)
  69             """, streamWriter.result());
  70     }
  71
  72     @Test
  73     public void testAugmentationIdentifier() throws IOException {
  74         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
  75
  76         final QName augmented = QName.create("augment-namespace", "augmented-container");
  77
  78         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
  79             .node(QName.create("test", "container-1"))
  80             .node(AugmentationIdentifier.create(Set.of(augmented)))
  81             .node(augmented)
  82             .node(QName.create(augmented, "container-2"))
  83             .build();
  84
  85         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
  86             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
  87                 nnWriter.write(mockedPayload());
  88             }
  89         }
  90
  91         assertEquals("""
  92             (test)container-1(container)
  93               AugmentationIdentifier{childNames=[(augment-namespace)augmented-container]}(augmentation)
  94                 (augment-namespace)augmented-container(container)
  95                   (augment-namespace)container-2(container)
  96                     (test)payload-container(container)
  97                       (test)payload-leaf(leaf)
  98                         (String)=leaf-value
  99                       (end)
 100                     (end)
 101                   (end)
 102                 (end)
 103               (end)
 104             (end)
 105             """, streamWriter.result());
 106     }
 107
 108     @Test
 109     public void testMapIdentifier() throws IOException {
 110         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 111
 112         final QName listQname = QName.create("test", "list-1");
 113
 114         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 115             .node(listQname)
 116             .nodeWithKey(listQname, QName.create("test", "list-1-key"), "test-list-entry")
 117             .node(QName.create("test", "container-1"))
 118             .build();
 119
 120         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
 121             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 122                 nnWriter.write(mockedPayload());
 123             }
 124         }
 125
 126         assertEquals("""
 127             (test)list-1(key)
 128               (test)list-1[{(test)list-1-key=test-list-entry}][](key)
 129                 (test)container-1(container)
 130                   (test)payload-container(container)
 131                     (test)payload-leaf(leaf)
 132                       (String)=leaf-value
 133                     (end)
 134                   (end)
 135                 (end)
 136               (end)
 137             (end)
 138             """, streamWriter.result());
 139     }
 140
 141     @Test
 142     public void testChoiceIdentifier() throws IOException {
 143         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 144
 145         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 146             .node(QName.create("test", "choice-node"))
 147             .node(QName.create("test", "container-in-case"))
 148             .build();
 149
 150         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
 151             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 152                 nnWriter.write(mockedPayload());
 153             }
 154         }
 155
 156         assertEquals("""
 157             (test)choice-node(choice)
 158               (test)container-in-case(container)
 159                 (test)payload-container(container)
 160                   (test)payload-leaf(leaf)
 161                     (String)=leaf-value
 162                   (end)
 163                 (end)
 164               (end)
 165             (end)
 166             """, streamWriter.result());
 167     }
 168
 169     @Test
 170     public void testLeafSetIdentifier() throws IOException {
 171         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 172
 173         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 174             .node(QName.create("test", "list-list"))
 175             .build();
 176
 177         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
 178             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 179                 final QName leafQname = QName.create("test", "leaf");
 180
 181                 final LeafSetEntryNode<?> leafNode = mock(LeafSetEntryNode.class);
 182                 doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafNode).getIdentifier();
 183                 doReturn("test-value").when(leafNode).body();
 184                 nnWriter.write(leafNode);
 185
 186                 final LeafSetEntryNode<?> leafNode2 = mock(LeafSetEntryNode.class);
 187                 doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafNode2).getIdentifier();
 188                 doReturn("test-value-2").when(leafNode2).body();
 189                 nnWriter.write(leafNode2);
 190             }
 191         }
 192
 193         assertEquals("""
 194             (test)list-list(leaf-list)
 195               (test)leaf(entry)
 196                 (String)=test-value
 197               (end)
 198               (test)leaf(entry)
 199                 (String)=test-value-2
 200               (end)
 201             (end)
 202             """, streamWriter.result());
 203     }
 204
 205     private static NormalizedNode mockedPayload() {
 206         final ContainerNode containerNode = mock(ContainerNode.class);
 207         final LeafNode<?> leafNode = mock(LeafNode.class);
 208
 209         doReturn(new NodeIdentifier(QName.create("test", "payload-container"))).when(containerNode).getIdentifier();
 210         doReturn(Set.of(leafNode)).when(containerNode).body();
 211         doReturn(new NodeIdentifier(QName.create("test", "payload-leaf"))).when(leafNode).getIdentifier();
 212         doReturn("leaf-value").when(leafNode).body();
 213
 214         return containerNode;
 215     }
 216 }