Adjust to yangtools-2.0.0/odlparent-3.0.0 changes
[netconf.git] / restconf / restconf-nb-bierman02 / src / test / java / org / opendaylight / netconf / sal / rest / impl / DepthAwareNormalizedNodeWriterTest.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
9 package org.opendaylight.netconf.sal.rest.impl;
10
11 import com.google.common.collect.Sets;
12 import java.util.Collection;
13 import java.util.Collections;
14 import java.util.Optional;
15 import org.junit.Before;
16 import org.junit.Ignore;
17 import org.junit.Test;
18 import org.mockito.InOrder;
19 import org.mockito.Mock;
20 import org.mockito.Mockito;
21 import org.mockito.MockitoAnnotations;
22 import org.opendaylight.yangtools.yang.common.QName;
23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
27 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
28 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
29 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
30 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
31 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
35
36 public class DepthAwareNormalizedNodeWriterTest {
37
38     @Mock
39     private NormalizedNodeStreamWriter writer;
40     @Mock
41     private ContainerNode containerNodeData;
42     @Mock
43     private MapNode mapNodeData;
44     @Mock
45     private MapEntryNode mapEntryNodeData;
46     @Mock
47     private LeafSetNode<String> leafSetNodeData;
48     @Mock
49     private LeafSetEntryNode<String> leafSetEntryNodeData;
50     @Mock
51     private LeafNode<String> keyLeafNodeData;
52     @Mock
53     private LeafNode<String> anotherLeafNodeData;
54
55     private NodeIdentifier containerNodeIdentifier;
56     private NodeIdentifier mapNodeIdentifier;
57     private NodeIdentifierWithPredicates mapEntryNodeIdentifier;
58     private NodeIdentifier leafSetNodeIdentifier;
59     private NodeWithValue<?> leafSetEntryNodeIdentifier;
60     private NodeIdentifier keyLeafNodeIdentifier;
61     private NodeIdentifier anotherLeafNodeIdentifier;
62
63     private Collection<DataContainerChild<?, ?>> containerNodeValue;
64     private Collection<MapEntryNode> mapNodeValue;
65     private Collection<DataContainerChild<?, ?>> mapEntryNodeValue;
66     private Collection<LeafSetEntryNode<String>> leafSetNodeValue;
67     private String leafSetEntryNodeValue;
68     private String keyLeafNodeValue;
69     private String anotherLeafNodeValue;
70
71     @Before
72     public void setUp() {
73         MockitoAnnotations.initMocks(this);
74
75         // identifiers
76         containerNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "container"));
77         Mockito.when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
78
79         mapNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "list"));
80         Mockito.when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier);
81
82         final QName leafSetEntryNodeQName = QName.create("namespace", "leaf-set-entry");
83         leafSetEntryNodeValue = "leaf-set-value";
84         leafSetEntryNodeIdentifier = new NodeWithValue<>(leafSetEntryNodeQName, leafSetEntryNodeValue);
85         Mockito.when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
86         Mockito.when(leafSetEntryNodeData.getNodeType()).thenReturn(leafSetEntryNodeQName);
87
88         leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set"));
89         Mockito.when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
90
91         final QName mapEntryNodeKey = QName.create("namespace", "key-field");
92         keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
93         keyLeafNodeValue = "key-value";
94
95         mapEntryNodeIdentifier = new YangInstanceIdentifier.NodeIdentifierWithPredicates(
96                 QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue));
97         Mockito.when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
98         Mockito.when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
99
100         Mockito.when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue);
101         Mockito.when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier);
102
103         anotherLeafNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "another-field"));
104         anotherLeafNodeValue = "another-value";
105
106         Mockito.when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue);
107         Mockito.when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier);
108
109         // values
110         Mockito.when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue);
111
112         leafSetNodeValue = Collections.singletonList(leafSetEntryNodeData);
113         Mockito.when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue);
114
115         containerNodeValue = Collections.singleton(leafSetNodeData);
116         Mockito.when(containerNodeData.getValue()).thenReturn(containerNodeValue);
117
118         mapEntryNodeValue = Sets.newHashSet(keyLeafNodeData, anotherLeafNodeData);
119         Mockito.when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue);
120
121         mapNodeValue = Collections.singleton(mapEntryNodeData);
122         Mockito.when(mapNodeData.getValue()).thenReturn(mapNodeValue);
123     }
124
125     /**
126      * Test write {@link ContainerNode} with children but write data only to depth 1 (children will not be written).
127      */
128     @Test
129     public void writeContainerWithoutChildrenTest() throws Exception {
130         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(writer, 1);
131
132         depthWriter.write(containerNodeData);
133
134         final InOrder inOrder = Mockito.inOrder(writer);
135         inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
136         inOrder.verify(writer, Mockito.times(1)).endNode();
137         Mockito.verifyNoMoreInteractions(writer);
138     }
139
140     /**
141      * Test write {@link ContainerNode} with children and write also all its children.
142      */
143     @Test
144     public void writeContainerWithChildrenTest() throws Exception {
145         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
146                 writer, Integer.MAX_VALUE);
147
148         depthWriter.write(containerNodeData);
149
150         final InOrder inOrder = Mockito.inOrder(writer);
151         inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
152         inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
153         inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
154                 leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
155         inOrder.verify(writer, Mockito.times(2)).endNode();
156         Mockito.verifyNoMoreInteractions(writer);
157     }
158
159     /**
160      * Test write with {@link MapNode} with children but write data only to depth 1 (children will not be written).
161      */
162     @Test
163     public void writeMapNodeWithoutChildrenTest() throws Exception {
164         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(writer, 1);
165
166         depthWriter.write(mapNodeData);
167
168         final InOrder inOrder = Mockito.inOrder(writer);
169         inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
170         inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
171         inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
172         inOrder.verify(writer, Mockito.times(2)).endNode();
173         Mockito.verifyNoMoreInteractions(writer);
174     }
175
176     /**
177      * Test write {@link MapNode} with children and write also all its children.
178      * FIXME
179      * Although ordered writer is used leaves are not written in expected order.
180      *
181      */
182     @Ignore
183     @Test
184     public void writeMapNodeWithChildrenTest() throws Exception {
185         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
186                 writer, Integer.MAX_VALUE);
187
188         depthWriter.write(mapNodeData);
189
190         final InOrder inOrder = Mockito.inOrder(writer);
191         inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
192         inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
193         inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
194         // FIXME this assertion is not working because leaves are not written in expected order
195         inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
196         inOrder.verify(writer, Mockito.times(2)).endNode();
197         Mockito.verifyNoMoreInteractions(writer);
198     }
199
200     /**
201      * Test write with {@link LeafSetNode} with depth 1 (children will not be written).
202      */
203     @Test
204     public void writeLeafSetNodeWithoutChildrenTest() throws Exception {
205         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
206                 writer, 1);
207
208         depthWriter.write(leafSetNodeData);
209
210         final InOrder inOrder = Mockito.inOrder(writer);
211         inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
212         inOrder.verify(writer, Mockito.times(1)).endNode();
213         Mockito.verifyNoMoreInteractions(writer);
214     }
215
216     /**
217      * Test write with {@link LeafSetNode} when all its children will be written.
218      */
219     @Test
220     public void writeLeafSetNodeWithChildrenTest() throws Exception {
221         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
222                 writer, Integer.MAX_VALUE);
223
224         depthWriter.write(leafSetNodeData);
225
226         final InOrder inOrder = Mockito.inOrder(writer);
227         inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
228         inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
229                 leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
230         inOrder.verify(writer, Mockito.times(1)).endNode();
231         Mockito.verifyNoMoreInteractions(writer);
232     }
233
234     /**
235      * Test write with {@link LeafSetEntryNode}.
236      */
237     @Test
238     public void writeLeafSetEntryNodeTest() throws Exception {
239         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
240                 writer, Integer.MAX_VALUE);
241
242         depthWriter.write(leafSetEntryNodeData);
243
244         final InOrder inOrder = Mockito.inOrder(writer);
245         inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
246                 leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
247         Mockito.verifyNoMoreInteractions(writer);
248     }
249
250     /**
251      * Test write with {@link MapEntryNode} unordered to depth 1 to write only keys.
252      */
253     @Test
254     public void writeMapEntryNodeUnorderedOnlyKeysTest() throws Exception {
255         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
256                 writer, false, 1);
257
258         depthWriter.write(mapEntryNodeData);
259
260         final InOrder inOrder = Mockito.inOrder(writer);
261         inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
262         // write only the key
263         inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
264         inOrder.verify(writer, Mockito.times(1)).endNode();
265         Mockito.verifyNoMoreInteractions(writer);
266     }
267
268     /**
269      * Test write with {@link MapEntryNode} unordered with full depth.
270      */
271     @Test
272     public void writeMapEntryNodeUnorderedTest() throws Exception {
273         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
274                 writer, false, Integer.MAX_VALUE);
275
276         depthWriter.write(mapEntryNodeData);
277
278         // unordered
279         Mockito.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
280         Mockito.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
281         Mockito.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
282         Mockito.verify(writer, Mockito.times(1)).endNode();
283         Mockito.verifyNoMoreInteractions(writer);
284     }
285
286     /**
287      * Test write with {@link MapEntryNode} ordered with depth 1 (children will not be written).
288      */
289     @Test
290     public void writeMapEntryNodeOrderedWithoutChildrenTest() throws Exception {
291         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
292                 writer, true, 1);
293
294         depthWriter.write(mapEntryNodeData);
295
296         final InOrder inOrder = Mockito.inOrder(writer);
297         inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
298         inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
299         inOrder.verify(writer, Mockito.times(1)).endNode();
300         Mockito.verifyNoMoreInteractions(writer);
301     }
302
303     /**
304      * Test write with {@link MapEntryNode} ordered and write also all its children.
305      * FIXME
306      * Although ordered writer is used leaves are not written in expected order.
307      *
308      */
309     @Ignore
310     @Test
311     public void writeMapEntryNodeOrderedTest() throws Exception {
312         final DepthAwareNormalizedNodeWriter depthWriter = DepthAwareNormalizedNodeWriter.forStreamWriter(
313                 writer, true, Integer.MAX_VALUE);
314
315         depthWriter.write(mapEntryNodeData);
316
317         final InOrder inOrder = Mockito.inOrder(writer);
318         inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
319         inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
320         // FIXME this assertion is not working because leaves are not written in expected order
321         inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
322         inOrder.verify(writer, Mockito.times(1)).endNode();
323         Mockito.verifyNoMoreInteractions(writer);
324     }
325 }