restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterParametersTest.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.verifyNoMoreInteractions;
  13 import static org.mockito.Mockito.when;
  14
  15 import java.util.Collection;
  16 import java.util.List;
  17 import java.util.Set;
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.junit.runner.RunWith;
  21 import org.mockito.InOrder;
  22 import org.mockito.Mock;
  23 import org.mockito.junit.MockitoJUnitRunner;
  24 import org.opendaylight.restconf.nb.rfc8040.DepthParam;
  25 import org.opendaylight.yangtools.yang.common.QName;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  28 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  29 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  30 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  31 import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
  32 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  33 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
  34 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  35
  36 /**
  37  * Unit test for {@link ParameterAwareNormalizedNodeWriter} used with all parameters.
  38  */
  39 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  40 public class ParameterAwareNormalizedNodeWriterParametersTest {
  41     @Mock
  42     private NormalizedNodeStreamWriter writer;
  43     @Mock
  44     private ContainerNode containerNodeData;
  45     @Mock
  46     private SystemLeafSetNode<String> leafSetNodeData;
  47     @Mock
  48     private LeafSetEntryNode<String> leafSetEntryNodeData;
  49     @Mock
  50     private ContainerNode rootDataContainerData;
  51
  52     private NodeIdentifier containerNodeIdentifier;
  53     private NodeIdentifier leafSetNodeIdentifier;
  54     private NodeWithValue<String> leafSetEntryNodeIdentifier;
  55
  56     private Collection<DataContainerChild> containerNodeValue;
  57     private Collection<LeafSetEntryNode<String>> leafSetNodeValue;
  58     private String leafSetEntryNodeValue;
  59     private Collection<DataContainerChild> rootDataContainerValue;
  60
  61     @Before
  62     public void setUp() {
  63         // identifiers
  64         containerNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "container"));
  65         when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
  66
  67         final QName leafSetEntryNodeQName = QName.create("namespace", "leaf-set-entry");
  68         leafSetEntryNodeValue = "leaf-set-value";
  69         leafSetEntryNodeIdentifier = new NodeWithValue<>(leafSetEntryNodeQName, leafSetEntryNodeValue);
  70         when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
  71
  72         leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set"));
  73         when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
  74
  75         // values
  76         when(leafSetEntryNodeData.body()).thenReturn(leafSetEntryNodeValue);
  77
  78         leafSetNodeValue = List.of(leafSetEntryNodeData);
  79         when(leafSetNodeData.body()).thenReturn(leafSetNodeValue);
  80
  81         containerNodeValue = Set.of(leafSetNodeData);
  82         when(containerNodeData.body()).thenReturn(containerNodeValue);
  83
  84         rootDataContainerValue = Set.of(leafSetNodeData);
  85         when(rootDataContainerData.getIdentifier()).thenReturn(NodeIdentifier.create(
  86             QName.create("urn:ietf:params:xml:ns:netconf:base:1.0", "data")));
  87         when(rootDataContainerData.body()).thenReturn(rootDataContainerValue);
  88     }
  89
  90     /**
  91      * Test write {@link ContainerNode} when all its children are selected to be written by fields parameter.
  92      * Depth parameter is also used and limits output to depth 1.
  93      * Fields parameter has effect limiting depth parameter in the way that selected nodes and its ancestors are
  94      * written regardless of their depth (some of container children have depth > 1).
  95      * Fields parameter selects all container children to be written and also all children of those children.
  96      */
  97     @Test
  98     public void writeContainerParameterPrioritiesTest() throws Exception {
  99         final List<Set<QName>> limitedFields = List.of(
 100             Set.of(leafSetNodeIdentifier.getNodeType()),
 101             Set.of(leafSetEntryNodeIdentifier.getNodeType()));
 102
 103         final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
 104                 writer, DepthParam.min(), limitedFields);
 105
 106         parameterWriter.write(containerNodeData);
 107
 108         final InOrder inOrder = inOrder(writer);
 109         inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
 110         inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
 111         inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
 112         inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
 113         inOrder.verify(writer, times(3)).endNode();
 114         verifyNoMoreInteractions(writer);
 115     }
 116
 117     /**
 118      * Test write {@link ContainerNode} which represents data at restconf/data root.
 119      * No parameters are used.
 120      */
 121     @Test
 122     public void writeRootDataTest() throws Exception {
 123         final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
 124                 writer, null, null);
 125
 126         parameterWriter.write(rootDataContainerData);
 127
 128         final InOrder inOrder = inOrder(writer);
 129         inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
 130         inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
 131         inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
 132         inOrder.verify(writer, times(2)).endNode();
 133         verifyNoMoreInteractions(writer);
 134     }
 135
 136     @Test
 137     public void writeEmptyRootContainerTest() throws Exception {
 138         final ParameterAwareNormalizedNodeWriter parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(
 139                 writer, null, null);
 140
 141         parameterWriter.write(ImmutableContainerNodeBuilder.create()
 142                 .withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME)).build());
 143     }
 144 }