2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.restconf.server.spi;
10 import static org.mockito.Mockito.inOrder;
11 import static org.mockito.Mockito.times;
12 import static org.mockito.Mockito.verify;
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;
32 * Unit test for {@link NormalizedNodeWriter} used with depth parameter.
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"));
40 private final MapEntryNode mapEntryNodeData = ImmutableNodes.newMapEntryBuilder()
41 .withNodeIdentifier(mapEntryNodeIdentifier)
42 .withChild(keyLeafNodeData)
43 .withChild(ImmutableNodes.leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue))
45 private final SystemMapNode mapNodeData = ImmutableNodes.newSystemMapBuilder()
46 .withNodeIdentifier(LIST_NID)
47 .withChild(mapEntryNodeData)
51 private NormalizedNodeStreamWriter writer;
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.
58 void writeContainerWithoutChildrenDepthTest() throws Exception {
59 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
61 parameterWriter.write(containerNodeData);
63 final var inOrder = inOrder(writer);
64 inOrder.verify(writer).startContainerNode(CONTAINER_NID, 1);
65 inOrder.verify(writer).endNode();
69 * Test write {@link ContainerNode} with children and write also all its children.
70 * Depth parameter has higher value than maximal children depth.
73 void writeContainerWithChildrenDepthTest() throws Exception {
74 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
76 parameterWriter.write(containerNodeData);
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();
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.
91 void writeMapNodeWithoutChildrenDepthTest() throws Exception {
92 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
94 parameterWriter.write(mapNodeData);
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();
103 * Test write {@link MapNode} with children and write also all its children.
104 * Depth parameter has higher value than maximal children depth.
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());
111 parameterWriter.write(mapNodeData);
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();
129 * Test write with {@link LeafSetNode} with depth 1 (children will not be written).
130 * Depth parameter limits depth to 1.
133 void writeLeafSetNodeWithoutChildrenDepthTest() throws Exception {
134 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
136 parameterWriter.write(leafSetNodeData);
138 final var inOrder = inOrder(writer);
139 inOrder.verify(writer).startLeafSet(LEAF_SET_NID, 1);
140 inOrder.verify(writer).endNode();
144 * Test write with {@link LeafSetNode} when all its children will be written.
145 * Depth parameter has higher value than maximal children depth.
148 void writeLeafSetNodeWithChildrenDepthTest() throws Exception {
149 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
151 parameterWriter.write(leafSetNodeData);
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();
161 * Test write with {@link LeafSetEntryNode}.
162 * Depth parameter has higher value than maximal children depth.
165 void writeLeafSetEntryNodeDepthTest() throws Exception {
166 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
168 parameterWriter.write(leafSetEntryNodeData);
170 final var inOrder = inOrder(writer);
171 inOrder.verify(writer).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
172 inOrder.verify(writer).scalarValue(leafSetEntryNodeValue);
173 inOrder.verify(writer).endNode();
177 * Test write with {@link MapEntryNode} unordered to depth 1 to write only keys.
178 * Depth parameter limits depth to 1.
181 void writeMapEntryNodeUnorderedOnlyKeysDepthTest() throws Exception {
182 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.min(), null);
184 parameterWriter.write(mapEntryNodeData);
186 final var inOrder = inOrder(writer);
187 inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
188 inOrder.verify(writer).endNode();
192 * Test write with {@link MapEntryNode} unordered with full depth.
193 * Depth parameter has higher value than maximal children depth.
196 void writeMapEntryNodeUnorderedDepthTest() throws Exception {
197 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, false, DepthParam.max(), null);
199 parameterWriter.write(mapEntryNodeData);
202 verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
203 verify(writer).startLeafNode(KEY_FIELD_NID);
204 verify(writer).scalarValue(keyLeafNodeValue);
205 verify(writer).startLeafNode(anotherLeafNodeIdentifier);
206 verify(writer).scalarValue(anotherLeafNodeValue);
207 verify(writer, times(3)).endNode();
211 * Test write with {@link MapEntryNode} ordered with depth 1 (children will not be written).
212 * Depth parameter limits depth to 1.
215 void writeMapEntryNodeOrderedWithoutChildrenTest() throws Exception {
216 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.min());
218 parameterWriter.write(mapEntryNodeData);
220 final var inOrder = inOrder(writer);
221 inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
222 inOrder.verify(writer).endNode();
226 * Test write with {@link MapEntryNode} ordered and write also all its children.
227 * Depth parameter has higher value than maximal children depth.
230 @Disabled("FIXME: Although ordered writer is used leaves are not written in expected order")
231 void writeMapEntryNodeOrderedTest() throws Exception {
232 final var parameterWriter = NormalizedNodeWriter.forStreamWriter(writer, DepthParam.max());
234 parameterWriter.write(mapEntryNodeData);
236 final var inOrder = inOrder(writer);
237 inOrder.verify(writer).startMapEntryNode(mapEntryNodeIdentifier, 2);
238 inOrder.verify(writer).startLeafNode(KEY_FIELD_NID);
239 inOrder.verify(writer).scalarValue(keyLeafNodeValue);
240 inOrder.verify(writer).endNode();
241 inOrder.verify(writer).startLeafNode(KEY_FIELD_NID);
242 inOrder.verify(writer).scalarValue(keyLeafNodeValue);
243 inOrder.verify(writer).endNode();
244 // FIXME this assertion is not working because leaves are not written in expected order
245 inOrder.verify(writer).startLeafNode(anotherLeafNodeIdentifier);
246 inOrder.verify(writer).scalarValue(anotherLeafNodeValue);
247 inOrder.verify(writer, times(2)).endNode();