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