restconf/restconf-nb/src/test/java/org/opendaylight/restconf/server/spi/NormalizedNodeWriterDepthTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. 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.restconf.server.spi;
   9
  10 import static org.mockito.Mockito.inOrder;
  11 import static org.mockito.Mockito.times;
  12 import static org.mockito.Mockito.verify;
  13
  14 import org.junit.jupiter.api.Disabled;
  15 import org.junit.jupiter.api.Test;
  16 import org.junit.jupiter.api.extension.ExtendWith;
  17 import org.mockito.Mock;
  18 import org.mockito.junit.jupiter.MockitoExtension;
  19 import org.opendaylight.restconf.api.query.DepthParam;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  22 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  23 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  24 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  25 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  26 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  27 import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
  28 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  29 import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
  30
  31 /**
  32  * Unit test for {@link NormalizedNodeWriter} used with depth parameter.
  33  */
  34 @ExtendWith(MockitoExtension.class)
  35 class NormalizedNodeWriterDepthTest extends AbstractNormalizedNodeWriterTest {
  36     private final String anotherLeafNodeValue = "another-value";
  37     private final NodeIdentifier anotherLeafNodeIdentifier =
  38         NodeIdentifier.create(QName.create("namespace", "another-field"));
  39
  40     private final MapEntryNode mapEntryNodeData = ImmutableNodes.newMapEntryBuilder()
  41         .withNodeIdentifier(mapEntryNodeIdentifier)
  42         .withChild(keyLeafNodeData)
  43         .withChild(ImmutableNodes.leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue))
  44         .build();
  45     private final SystemMapNode mapNodeData = ImmutableNodes.newSystemMapBuilder()
  46         .withNodeIdentifier(LIST_NID)
  47         .withChild(mapEntryNodeData)
  48         .build();
  49
  50     @Mock
  51     private NormalizedNodeStreamWriter writer;
  52
  53     /**
  54      * Test write {@link ContainerNode} with children but write data only to depth 1 (children will not be written).
  55      * Depth parameter is limited to 1.
  56      */
  57     @Test
  58     void writeContainerWithoutChildrenDepthTest() throws Exception {
  59         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
  60
  61         parameterWriter.write(containerNodeData);
  62
  63         final var inOrder = inOrder(writer);
  64         inOrder.verify(writer).startContainerNode(CONTAINER_NID, 1);
  65         inOrder.verify(writer).endNode();
  66     }
  67
  68     /**
  69      * Test write {@link ContainerNode} with children and write also all its children.
  70      * Depth parameter has higher value than maximal children depth.
  71      */
  72     @Test
  73     void writeContainerWithChildrenDepthTest() throws Exception {
  74         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
  75
  76         parameterWriter.write(containerNodeData);
  77
  78         final var inOrder = inOrder(writer);
  79         inOrder.verify(writer).startContainerNode(CONTAINER_NID, 1);
  80         inOrder.verify(writer).startLeafSet(LEAF_SET_NID, 1);
  81         inOrder.verify(writer).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
  82         inOrder.verify(writer).scalarValue(leafSetEntryNodeValue);
  83         inOrder.verify(writer, times(3)).endNode();
  84     }
  85
  86     /**
  87      * Test write with {@link MapNode} with children but write data only to depth 1 (children will not be written).
  88      * Depth parameter limits depth to 1.
  89      */
  90     @Test
  91     void writeMapNodeWithoutChildrenDepthTest() throws Exception {
  92         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
  93
  94         parameterWriter.write(mapNodeData);
  95
  96         final var inOrder = inOrder(writer);
  97         inOrder.verify(writer).startMapNode(LIST_NID, 1);
  98         inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
  99         inOrder.verify(writer, times(2)).endNode();
 100     }
 101
 102     /**
 103      * Test write {@link MapNode} with children and write also all its children.
 104      * Depth parameter has higher value than maximal children depth.
 105      */
 106     @Test
 107     @Disabled("FIXME: Although ordered writer is used leaves are not written in expected order")
 108     void writeMapNodeWithChildrenDepthTest() throws Exception {
 109         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
 110
 111         parameterWriter.write(mapNodeData);
 112
 113         final var inOrder = inOrder(writer);
 114         inOrder.verify(writer).startMapNode(LIST_NID, 1);
 115         inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
 116         inOrder.verify(writer).startLeafNode(KEY_FIELD_NID);
 117         inOrder.verify(writer).scalarValue(keyLeafNodeValue);
 118         inOrder.verify(writer).endNode();
 119         inOrder.verify(writer).startLeafNode(KEY_FIELD_NID);
 120         inOrder.verify(writer).scalarValue(keyLeafNodeValue);
 121         inOrder.verify(writer, times(2)).endNode();
 122         // FIXME this assertion is not working because leaves are not written in expected order
 123         inOrder.verify(writer).startLeafNode(anotherLeafNodeIdentifier);
 124         inOrder.verify(writer).scalarValue(anotherLeafNodeValue);
 125         inOrder.verify(writer, times(3)).endNode();
 126     }
 127
 128     /**
 129      * Test write with {@link LeafSetNode} with depth 1 (children will not be written).
 130      * Depth parameter limits depth to 1.
 131      */
 132     @Test
 133     void writeLeafSetNodeWithoutChildrenDepthTest() throws Exception {
 134         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
 135
 136         parameterWriter.write(leafSetNodeData);
 137
 138         final var inOrder = inOrder(writer);
 139         inOrder.verify(writer).startLeafSet(LEAF_SET_NID, 1);
 140         inOrder.verify(writer).endNode();
 141     }
 142
 143     /**
 144      * Test write with {@link LeafSetNode} when all its children will be written.
 145      * Depth parameter has higher value than maximal children depth.
 146      */
 147     @Test
 148     void writeLeafSetNodeWithChildrenDepthTest() throws Exception {
 149         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
 150
 151         parameterWriter.write(leafSetNodeData);
 152
 153         final var inOrder = inOrder(writer);
 154         inOrder.verify(writer).startLeafSet(LEAF_SET_NID, 1);
 155         inOrder.verify(writer).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
 156         inOrder.verify(writer).scalarValue(leafSetEntryNodeValue);
 157         inOrder.verify(writer, times(2)).endNode();
 158     }
 159
 160     /**
 161      * Test write with {@link LeafSetEntryNode}.
 162      * Depth parameter has higher value than maximal children depth.
 163      */
 164     @Test
 165     void writeLeafSetEntryNodeDepthTest() throws Exception {
 166         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
 167
 168         parameterWriter.write(leafSetEntryNodeData);
 169
 170         final var inOrder = inOrder(writer);
 171         inOrder.verify(writer).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
 172         inOrder.verify(writer).scalarValue(leafSetEntryNodeValue);
 173         inOrder.verify(writer).endNode();
 174     }
 175
 176     /**
 177      * Test write with {@link MapEntryNode} unordered to depth 1 to write only keys.
 178      * Depth parameter limits depth to 1.
 179      */
 180     @Test
 181     void writeMapEntryNodeUnorderedOnlyKeysDepthTest() throws Exception {
 182         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.min(), null);
 183
 184         parameterWriter.write(mapEntryNodeData);
 185
 186         final var inOrder = inOrder(writer);
 187         inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
 188         // write only the key
 189         inOrder.verify(writer).startLeafNode(KEY_FIELD_NID);
 190         inOrder.verify(writer).scalarValue(keyLeafNodeValue);
 191         inOrder.verify(writer, times(2)).endNode();
 192     }
 193
 194     /**
 195      * Test write with {@link MapEntryNode} unordered with full depth.
 196      * Depth parameter has higher value than maximal children depth.
 197      */
 198     @Test
 199     void writeMapEntryNodeUnorderedDepthTest() throws Exception {
 200         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.max(), null);
 201
 202         parameterWriter.write(mapEntryNodeData);
 203
 204         // unordered
 205         verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
 206         verify(writer).startLeafNode(KEY_FIELD_NID);
 207         verify(writer).scalarValue(keyLeafNodeValue);
 208         verify(writer).startLeafNode(anotherLeafNodeIdentifier);
 209         verify(writer).scalarValue(anotherLeafNodeValue);
 210         verify(writer, times(3)).endNode();
 211     }
 212
 213     /**
 214      * Test write with {@link MapEntryNode} ordered with depth 1 (children will not be written).
 215      * Depth parameter limits depth to 1.
 216      */
 217     @Test
 218     void writeMapEntryNodeOrderedWithoutChildrenTest() throws Exception {
 219         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
 220
 221         parameterWriter.write(mapEntryNodeData);
 222
 223         final var inOrder = inOrder(writer);
 224         inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
 225         inOrder.verify(writer).endNode();
 226     }
 227
 228     /**
 229      * Test write with {@link MapEntryNode} ordered and write also all its children.
 230      * Depth parameter has higher value than maximal children depth.
 231      */
 232     @Test
 233     @Disabled("FIXME: Although ordered writer is used leaves are not written in expected order")
 234     void writeMapEntryNodeOrderedTest() throws Exception {
 235         final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
 236
 237         parameterWriter.write(mapEntryNodeData);
 238
 239         final var inOrder = inOrder(writer);
 240         inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
 241         inOrder.verify(writer).startLeafNode(KEY_FIELD_NID);
 242         inOrder.verify(writer).scalarValue(keyLeafNodeValue);
 243         inOrder.verify(writer).endNode();
 244         inOrder.verify(writer).startLeafNode(KEY_FIELD_NID);
 245         inOrder.verify(writer).scalarValue(keyLeafNodeValue);
 246         inOrder.verify(writer).endNode();
 247         // FIXME this assertion is not working because leaves are not written in expected order
 248         inOrder.verify(writer).startLeafNode(anotherLeafNodeIdentifier);
 249         inOrder.verify(writer).scalarValue(anotherLeafNodeValue);
 250         inOrder.verify(writer, times(2)).endNode();
 251     }
 252 }