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.nb.rfc8040.jersey.providers;
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.restconf.nb.rfc8040.DepthParam;
28 import org.opendaylight.yangtools.yang.common.QName;
29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
31 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
32 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
34 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
35 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
36 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
37 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
38 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
39 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
42 * Unit test for {@link ParameterAwareNormalizedNodeWriter} used with depth parameter.
44 @RunWith(MockitoJUnitRunner.StrictStubs.class)
45 public class ParameterAwareNormalizedNodeWriterDepthTest {
48 private NormalizedNodeStreamWriter writer;
50 private ContainerNode containerNodeData;
52 private MapNode mapNodeData;
54 private MapEntryNode mapEntryNodeData;
56 private LeafSetNode<String> leafSetNodeData;
58 private LeafSetEntryNode<String> leafSetEntryNodeData;
60 private LeafNode<String> keyLeafNodeData;
62 private LeafNode<String> anotherLeafNodeData;
64 private NodeIdentifier containerNodeIdentifier;
65 private NodeIdentifier mapNodeIdentifier;
66 private NodeIdentifierWithPredicates mapEntryNodeIdentifier;
67 private NodeIdentifier leafSetNodeIdentifier;
68 private NodeWithValue<String> leafSetEntryNodeIdentifier;
69 private NodeIdentifier keyLeafNodeIdentifier;
70 private NodeIdentifier anotherLeafNodeIdentifier;
72 private Collection<DataContainerChild> containerNodeValue;
73 private Collection<MapEntryNode> mapNodeValue;
74 private Collection<DataContainerChild> mapEntryNodeValue;
75 private Collection<LeafSetEntryNode<String>> leafSetNodeValue;
76 private String leafSetEntryNodeValue;
77 private String keyLeafNodeValue;
78 private String anotherLeafNodeValue;
83 containerNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "container"));
84 when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
86 mapNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "list"));
87 when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier);
89 final QName leafSetEntryNodeQName = QName.create("namespace", "leaf-set-entry");
90 leafSetEntryNodeValue = "leaf-set-value";
91 leafSetEntryNodeIdentifier = new NodeWithValue<>(leafSetEntryNodeQName, leafSetEntryNodeValue);
92 when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
94 leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set"));
95 when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
97 final QName mapEntryNodeKey = QName.create("namespace", "key-field");
98 keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
99 keyLeafNodeValue = "key-value";
101 mapEntryNodeIdentifier = NodeIdentifierWithPredicates.of(
102 QName.create("namespace", "list-entry"), mapEntryNodeKey, keyLeafNodeValue);
103 when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
104 when(mapEntryNodeData.findChildByArg(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
106 when(keyLeafNodeData.body()).thenReturn(keyLeafNodeValue);
107 when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier);
109 anotherLeafNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "another-field"));
110 anotherLeafNodeValue = "another-value";
112 when(anotherLeafNodeData.body()).thenReturn(anotherLeafNodeValue);
113 when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier);
116 when(leafSetEntryNodeData.body()).thenReturn(leafSetEntryNodeValue);
118 leafSetNodeValue = Collections.singletonList(leafSetEntryNodeData);
119 when(leafSetNodeData.body()).thenReturn(leafSetNodeValue);
121 containerNodeValue = Collections.singleton(leafSetNodeData);
122 when(containerNodeData.body()).thenReturn(containerNodeValue);
124 mapEntryNodeValue = Sets.newHashSet(keyLeafNodeData, anotherLeafNodeData);
125 when(mapEntryNodeData.body()).thenReturn(mapEntryNodeValue);
127 mapNodeValue = Collections.singleton(mapEntryNodeData);
128 when(mapNodeData.body()).thenReturn(mapNodeValue);
132 * Test write {@link ContainerNode} with children but write data only to depth 1 (children will not be written).
133 * Depth parameter is limited to 1.
136 public void writeContainerWithoutChildrenDepthTest() throws Exception {
137 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
138 writer, DepthParam.min(), null);
140 parameterWriter.write(containerNodeData);
142 final InOrder inOrder = inOrder(writer);
143 inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
144 inOrder.verify(writer, times(1)).endNode();
145 verifyNoMoreInteractions(writer);
149 * Test write {@link ContainerNode} with children and write also all its children.
150 * Depth parameter has higher value than maximal children depth.
153 public void writeContainerWithChildrenDepthTest() throws Exception {
154 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
155 writer, DepthParam.max(), null);
157 parameterWriter.write(containerNodeData);
159 final InOrder inOrder = inOrder(writer);
160 inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
161 inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
162 inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
163 inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
164 inOrder.verify(writer, times(3)).endNode();
165 verifyNoMoreInteractions(writer);
169 * Test write with {@link MapNode} with children but write data only to depth 1 (children will not be written).
170 * Depth parameter limits depth to 1.
173 public void writeMapNodeWithoutChildrenDepthTest() throws Exception {
174 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
175 writer, DepthParam.min(), null);
177 parameterWriter.write(mapNodeData);
179 final InOrder inOrder = inOrder(writer);
180 inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
181 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
182 inOrder.verify(writer, times(2)).endNode();
183 verifyNoMoreInteractions(writer);
187 * Test write {@link MapNode} with children and write also all its children.
188 * Depth parameter has higher value than maximal children depth.
190 * Although ordered writer is used leaves are not written in expected order.
195 public void writeMapNodeWithChildrenDepthTest() throws Exception {
196 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
197 writer, DepthParam.max(), null);
199 parameterWriter.write(mapNodeData);
201 final InOrder inOrder = inOrder(writer);
202 inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
203 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
204 inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier);
205 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
206 inOrder.verify(writer, times(1)).endNode();
207 inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier);
208 inOrder.verify(writer, times(2)).scalarValue(keyLeafNodeValue);
209 inOrder.verify(writer, times(2)).endNode();
210 // FIXME this assertion is not working because leaves are not written in expected order
211 inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
212 inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
213 inOrder.verify(writer, times(3)).endNode();
214 verifyNoMoreInteractions(writer);
218 * Test write with {@link LeafSetNode} with depth 1 (children will not be written).
219 * Depth parameter limits depth to 1.
222 public void writeLeafSetNodeWithoutChildrenDepthTest() throws Exception {
223 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
224 writer, DepthParam.min(), null);
226 parameterWriter.write(leafSetNodeData);
228 final InOrder inOrder = inOrder(writer);
229 inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
230 inOrder.verify(writer, times(1)).endNode();
231 verifyNoMoreInteractions(writer);
235 * Test write with {@link LeafSetNode} when all its children will be written.
236 * Depth parameter has higher value than maximal children depth.
239 public void writeLeafSetNodeWithChildrenDepthTest() throws Exception {
240 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
241 writer, DepthParam.max(), null);
243 parameterWriter.write(leafSetNodeData);
245 final InOrder inOrder = inOrder(writer);
246 inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
247 inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
248 inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
249 inOrder.verify(writer, times(2)).endNode();
250 verifyNoMoreInteractions(writer);
254 * Test write with {@link LeafSetEntryNode}.
255 * Depth parameter has higher value than maximal children depth.
258 public void writeLeafSetEntryNodeDepthTest() throws Exception {
259 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
260 writer, DepthParam.max(), null);
262 parameterWriter.write(leafSetEntryNodeData);
264 final InOrder inOrder = inOrder(writer);
265 inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
266 inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
267 inOrder.verify(writer, times(1)).endNode();
268 verifyNoMoreInteractions(writer);
272 * Test write with {@link MapEntryNode} unordered to depth 1 to write only keys.
273 * Depth parameter limits depth to 1.
276 public void writeMapEntryNodeUnorderedOnlyKeysDepthTest() throws Exception {
277 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
278 writer, false, DepthParam.min(), null);
280 parameterWriter.write(mapEntryNodeData);
282 final InOrder inOrder = inOrder(writer);
283 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
284 // write only the key
285 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
286 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
287 inOrder.verify(writer, times(2)).endNode();
288 verifyNoMoreInteractions(writer);
292 * Test write with {@link MapEntryNode} unordered with full depth.
293 * Depth parameter has higher value than maximal children depth.
296 public void writeMapEntryNodeUnorderedDepthTest() throws Exception {
297 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
298 writer, false, DepthParam.max(), null);
300 parameterWriter.write(mapEntryNodeData);
303 verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
304 verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
305 verify(writer, times(1)).scalarValue(keyLeafNodeValue);
306 verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
307 verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
308 verify(writer, times(3)).endNode();
309 verifyNoMoreInteractions(writer);
313 * Test write with {@link MapEntryNode} ordered with depth 1 (children will not be written).
314 * Depth parameter limits depth to 1.
317 public void writeMapEntryNodeOrderedWithoutChildrenTest() throws Exception {
318 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
319 writer, true, DepthParam.min(), null);
321 parameterWriter.write(mapEntryNodeData);
323 final InOrder inOrder = inOrder(writer);
324 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
325 inOrder.verify(writer, times(1)).endNode();
326 verifyNoMoreInteractions(writer);
330 * Test write with {@link MapEntryNode} ordered and write also all its children.
331 * Depth parameter has higher value than maximal children depth.
333 * Although ordered writer is used leaves are not written in expected order.
338 public void writeMapEntryNodeOrderedTest() throws Exception {
339 final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
340 writer, true, DepthParam.max(), null);
342 parameterWriter.write(mapEntryNodeData);
344 final InOrder inOrder = inOrder(writer);
345 inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
346 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
347 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
348 inOrder.verify(writer, times(1)).endNode();
349 inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
350 inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
351 inOrder.verify(writer, times(1)).endNode();
352 // FIXME this assertion is not working because leaves are not written in expected order
353 inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
354 inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
355 inOrder.verify(writer, times(2)).endNode();
356 verifyNoMoreInteractions(writer);