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