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