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     public 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("(test)container-1(container)\n"
  58             + "  (test)container-2(container)\n"
  59             + "    (test)container-3(container)\n"
  60             + "      (test)payload-container(container)\n"
  61             + "        (test)payload-leaf(leaf)\n"
  62             + "          (String)=leaf-value\n"
  63             + "        (end)\n"
  64             + "      (end)\n"
  65             + "    (end)\n"
  66             + "  (end)\n"
  67             + "(end)\n", streamWriter.result());
  68     }
  69
  70     @Test
  71     public void testAugmentationIdentifier() throws IOException {
  72         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
  73
  74         final QName augmented = QName.create("augment-namespace", "augmented-container");
  75
  76         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
  77             .node(QName.create("test", "container-1"))
  78             .node(AugmentationIdentifier.create(Set.of(augmented)))
  79             .node(augmented)
  80             .node(QName.create(augmented, "container-2"))
  81             .build();
  82
  83         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
  84             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
  85                 nnWriter.write(mockedPayload());
  86             }
  87         }
  88
  89         assertEquals("(test)container-1(container)\n"
  90             + "  AugmentationIdentifier{childNames=[(augment-namespace)augmented-container]}(augmentation)\n"
  91             + "    (augment-namespace)augmented-container(container)\n"
  92             + "      (augment-namespace)container-2(container)\n"
  93             + "        (test)payload-container(container)\n"
  94             + "          (test)payload-leaf(leaf)\n"
  95             + "            (String)=leaf-value\n"
  96             + "          (end)\n"
  97             + "        (end)\n"
  98             + "      (end)\n"
  99             + "    (end)\n"
 100             + "  (end)\n"
 101             + "(end)\n", streamWriter.result());
 102     }
 103
 104     @Test
 105     public void testMapIdentifier() throws IOException {
 106         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 107
 108         final QName listQname = QName.create("test", "list-1");
 109
 110         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 111             .node(listQname)
 112             .nodeWithKey(listQname, QName.create("test", "list-1-key"), "test-list-entry")
 113             .node(QName.create("test", "container-1"))
 114             .build();
 115
 116         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
 117             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 118                 nnWriter.write(mockedPayload());
 119             }
 120         }
 121
 122         assertEquals("(test)list-1(key)\n"
 123             + "  (test)list-1[{(test)list-1-key=test-list-entry}][](key)\n"
 124             + "    (test)container-1(container)\n"
 125             + "      (test)payload-container(container)\n"
 126             + "        (test)payload-leaf(leaf)\n"
 127             + "          (String)=leaf-value\n"
 128             + "        (end)\n"
 129             + "      (end)\n"
 130             + "    (end)\n"
 131             + "  (end)\n"
 132             + "(end)\n", streamWriter.result());
 133     }
 134
 135     @Test
 136     public void testChoiceIdentifier() throws IOException {
 137         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 138
 139         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 140             .node(QName.create("test", "choice-node"))
 141             .node(QName.create("test", "container-in-case"))
 142             .build();
 143
 144         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
 145             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 146                 nnWriter.write(mockedPayload());
 147             }
 148         }
 149
 150         assertEquals("(test)choice-node(choice)\n"
 151             + "  (test)container-in-case(container)\n"
 152             + "    (test)payload-container(container)\n"
 153             + "      (test)payload-leaf(leaf)\n"
 154             + "        (String)=leaf-value\n"
 155             + "      (end)\n"
 156             + "    (end)\n"
 157             + "  (end)\n"
 158             + "(end)\n", streamWriter.result());
 159     }
 160
 161     @Test
 162     public void testLeafSetIdentifier() throws IOException {
 163         final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
 164
 165         final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
 166             .node(QName.create("test", "list-list"))
 167             .build();
 168
 169         try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
 170             try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
 171                 final QName leafQname = QName.create("test", "leaf");
 172
 173                 final LeafSetEntryNode<?> leafNode = mock(LeafSetEntryNode.class);
 174                 doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafNode).getIdentifier();
 175                 doReturn("test-value").when(leafNode).body();
 176                 nnWriter.write(leafNode);
 177
 178                 final LeafSetEntryNode<?> leafNode2 = mock(LeafSetEntryNode.class);
 179                 doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafNode2).getIdentifier();
 180                 doReturn("test-value-2").when(leafNode2).body();
 181                 nnWriter.write(leafNode2);
 182             }
 183         }
 184
 185         assertEquals("(test)list-list(leaf-list)\n"
 186             + "  (test)leaf(entry)\n"
 187             + "    (String)=test-value\n"
 188             + "  (end)\n"
 189             + "  (test)leaf(entry)\n"
 190             + "    (String)=test-value-2\n"
 191             + "  (end)\n"
 192             + "(end)\n", streamWriter.result());
 193     }
 194
 195     private static NormalizedNode mockedPayload() {
 196         final ContainerNode containerNode = mock(ContainerNode.class);
 197         final LeafNode<?> leafNode = mock(LeafNode.class);
 198
 199         doReturn(new NodeIdentifier(QName.create("test", "payload-container"))).when(containerNode).getIdentifier();
 200         doReturn(Set.of(leafNode)).when(containerNode).body();
 201         doReturn(new NodeIdentifier(QName.create("test", "payload-leaf"))).when(leafNode).getIdentifier();
 202         doReturn("leaf-value").when(leafNode).body();
 203
 204         return containerNode;
 205     }
 206 }