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.netconf.sal.rest.impl;
10 import static org.mockito.Mockito.inOrder;
11 import static org.mockito.Mockito.times;
12 import static org.mockito.Mockito.verify;
13 import static org.mockito.Mockito.verifyNoMoreInteractions;
14 import static org.mockito.Mockito.when;
16 import com.google.common.collect.Sets;
17 import java.util.Collection;
18 import java.util.Collections;
19 import java.util.Optional;
20 import org.junit.Before;
21 import org.junit.Ignore;
22 import org.junit.Test;
23 import org.junit.runner.RunWith;
24 import org.mockito.InOrder;
25 import org.mockito.Mock;
26 import org.mockito.junit.MockitoJUnitRunner;
27 import org.opendaylight.yangtools.yang.common.QName;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
31 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
33 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
35 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
36 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
37 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
38 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
40 @RunWith(MockitoJUnitRunner.StrictStubs.class)
41 public class DepthAwareNormalizedNodeWriterTest {
44 private NormalizedNodeStreamWriter writer;
46 private ContainerNode containerNodeData;
48 private MapNode mapNodeData;
50 private MapEntryNode mapEntryNodeData;
52 private LeafSetNode<String> leafSetNodeData;
54 private LeafSetEntryNode<String> leafSetEntryNodeData;
56 private LeafNode<String> keyLeafNodeData;
58 private LeafNode<String> anotherLeafNodeData;
60 private NodeIdentifier containerNodeIdentifier;
61 private NodeIdentifier mapNodeIdentifier;
62 private NodeIdentifierWithPredicates mapEntryNodeIdentifier;
63 private NodeIdentifier leafSetNodeIdentifier;
64 private NodeWithValue<String> leafSetEntryNodeIdentifier;
65 private NodeIdentifier keyLeafNodeIdentifier;
66 private NodeIdentifier anotherLeafNodeIdentifier;
68 private Collection<DataContainerChild> containerNodeValue;
69 private Collection<MapEntryNode> mapNodeValue;
70 private Collection<DataContainerChild> mapEntryNodeValue;
71 private Collection<LeafSetEntryNode<String>> leafSetNodeValue;
72 private String leafSetEntryNodeValue;
73 private String keyLeafNodeValue;
74 private String anotherLeafNodeValue;
79 containerNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "container"));
80 when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
82 mapNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "list"));
83 when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier);
85 final QName leafSetEntryNodeQName = QName.create("namespace", "leaf-set-entry");
86 leafSetEntryNodeValue = "leaf-set-value";
87 leafSetEntryNodeIdentifier = new NodeWithValue<>(leafSetEntryNodeQName, leafSetEntryNodeValue);
88 when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
90 leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set"));
91 when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
93 final QName mapEntryNodeKey = QName.create("namespace", "key-field");
94 keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
95 keyLeafNodeValue = "key-value";
97 mapEntryNodeIdentifier = NodeIdentifierWithPredicates.of(
98 QName.create("namespace", "list-entry"), mapEntryNodeKey, keyLeafNodeValue);
99 when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
100 when(mapEntryNodeData.findChildByArg(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
102 when(keyLeafNodeData.body()).thenReturn(keyLeafNodeValue);
103 when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier);
105 anotherLeafNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "another-field"));
106 anotherLeafNodeValue = "another-value";
108 when(anotherLeafNodeData.body()).thenReturn(anotherLeafNodeValue);
109 when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier);
112 when(leafSetEntryNodeData.body()).thenReturn(leafSetEntryNodeValue);
114 leafSetNodeValue = Collections.singletonList(leafSetEntryNodeData);
115 when(leafSetNodeData.body()).thenReturn(leafSetNodeValue);
117 containerNodeValue = Collections.singleton(leafSetNodeData);
118 when(containerNodeData.body()).thenReturn(containerNodeValue);
120 mapEntryNodeValue = Sets.newHashSet(keyLeafNodeData, anotherLeafNodeData);
121 when(mapEntryNodeData.body()).thenReturn(mapEntryNodeValue);
123 mapNodeValue = Collections.singleton(mapEntryNodeData);
124 when(mapNodeData.body()).thenReturn(mapNodeValue);
128 * Test write {@link ContainerNode} with children but write data only to depth 1 (children will not be written).
131 public void writeContainerWithoutChildrenTest() throws Exception {
132 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(writer, 1);
134 depthWriter.write(containerNodeData);
136 final InOrder inOrder = inOrder(writer);
137 inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
138 inOrder.verify(writer, times(1)).endNode();
139 verifyNoMoreInteractions(writer);
143 * Test write {@link ContainerNode} with children and write also all its children.
146 public void writeContainerWithChildrenTest() throws Exception {
147 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
148 writer, Integer.MAX_VALUE);
150 depthWriter.write(containerNodeData);
152 final InOrder inOrder = inOrder(writer);
153 inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
154 inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
155 inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
156 inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
157 inOrder.verify(writer, times(3)).endNode();
158 verifyNoMoreInteractions(writer);
162 * Test write with {@link MapNode} with children but write data only to depth 1 (children will not be written).
165 public void writeMapNodeWithoutChildrenTest() throws Exception {
166 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(writer, 1);
168 depthWriter.write(mapNodeData);
170 final InOrder inOrder = inOrder(writer);
171 inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
172 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
173 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
174 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
175 inOrder.verify(writer, times(3)).endNode();
176 verifyNoMoreInteractions(writer);
180 * Test write {@link MapNode} with children and write also all its children.
182 * Although ordered writer is used leaves are not written in expected order.
187 public void writeMapNodeWithChildrenTest() throws Exception {
188 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
189 writer, Integer.MAX_VALUE);
191 depthWriter.write(mapNodeData);
193 final InOrder inOrder = inOrder(writer);
194 inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
195 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
196 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
197 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
198 inOrder.verify(writer, times(1)).endNode();
199 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
200 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
201 inOrder.verify(writer, times(1)).endNode();
203 // FIXME this assertion is not working because leaves are not written in expected order
204 inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
205 inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
206 inOrder.verify(writer, times(3)).endNode();
207 verifyNoMoreInteractions(writer);
211 * Test write with {@link LeafSetNode} with depth 1 (children will not be written).
214 public void writeLeafSetNodeWithoutChildrenTest() throws Exception {
215 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
218 depthWriter.write(leafSetNodeData);
220 final InOrder inOrder = inOrder(writer);
221 inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
222 inOrder.verify(writer, times(1)).endNode();
223 verifyNoMoreInteractions(writer);
227 * Test write with {@link LeafSetNode} when all its children will be written.
230 public void writeLeafSetNodeWithChildrenTest() throws Exception {
231 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
232 writer, Integer.MAX_VALUE);
234 depthWriter.write(leafSetNodeData);
236 final InOrder inOrder = inOrder(writer);
237 inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
238 inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
239 inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
240 inOrder.verify(writer, times(2)).endNode();
241 verifyNoMoreInteractions(writer);
245 * Test write with {@link LeafSetEntryNode}.
248 public void writeLeafSetEntryNodeTest() throws Exception {
249 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
250 writer, Integer.MAX_VALUE);
252 depthWriter.write(leafSetEntryNodeData);
254 final InOrder inOrder = inOrder(writer);
255 inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
256 inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
257 inOrder.verify(writer, times(1)).endNode();
258 verifyNoMoreInteractions(writer);
262 * Test write with {@link MapEntryNode} unordered to depth 1 to write only keys.
265 public void writeMapEntryNodeUnorderedOnlyKeysTest() throws Exception {
266 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
269 depthWriter.write(mapEntryNodeData);
271 final InOrder inOrder = inOrder(writer);
272 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
273 // write only the key
274 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
275 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
276 inOrder.verify(writer, times(2)).endNode();
277 verifyNoMoreInteractions(writer);
281 * Test write with {@link MapEntryNode} unordered with full depth.
284 public void writeMapEntryNodeUnorderedTest() throws Exception {
285 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
286 writer, false, Integer.MAX_VALUE);
288 depthWriter.write(mapEntryNodeData);
291 verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
292 verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
293 verify(writer, times(1)).scalarValue(keyLeafNodeValue);
294 verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
295 verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
296 verify(writer, times(3)).endNode();
297 verifyNoMoreInteractions(writer);
301 * Test write with {@link MapEntryNode} ordered with depth 1 (children will not be written).
304 public void writeMapEntryNodeOrderedWithoutChildrenTest() throws Exception {
305 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
308 depthWriter.write(mapEntryNodeData);
310 final InOrder inOrder = inOrder(writer);
311 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
312 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
313 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
314 inOrder.verify(writer, times(2)).endNode();
315 verifyNoMoreInteractions(writer);
319 * Test write with {@link MapEntryNode} ordered and write also all its children.
321 * Although ordered writer is used leaves are not written in expected order.
326 public void writeMapEntryNodeOrderedTest() throws Exception {
327 final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
328 writer, true, Integer.MAX_VALUE);
330 depthWriter.write(mapEntryNodeData);
332 final InOrder inOrder = inOrder(writer);
333 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
334 inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier);
335 inOrder.verify(writer, times(2)).scalarValue(keyLeafNodeValue);
336 inOrder.verify(writer, times(1)).endNode();
337 // FIXME this assertion is not working because leaves are not written in expected order
338 inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
339 inOrder.verify(writer, times(2)).scalarValue(anotherLeafNodeValue);
340 inOrder.verify(writer, times(2)).endNode();
341 verifyNoMoreInteractions(writer);