restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtilTest.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.rests.utils;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNull;
  12 import static org.mockito.Mockito.doReturn;
  13 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
  14
  15 import com.google.common.collect.ImmutableList;
  16 import java.util.Optional;
  17 import org.eclipse.jdt.annotation.NonNull;
  18 import org.eclipse.jdt.annotation.Nullable;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.Mock;
  23 import org.mockito.junit.MockitoJUnitRunner;
  24 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  25 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  26 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  27 import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
  28 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
  29 import org.opendaylight.restconf.nb.rfc8040.ContentParam;
  30 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
  31 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
  32 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
  33 import org.opendaylight.yangtools.yang.common.QName;
  34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  35 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  36 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  37 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  38 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  39 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  40 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  41 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
  42 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  43 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  44
  45 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  46 public class ReadDataTransactionUtilTest {
  47     private static final TestData DATA = new TestData();
  48     private static final NodeIdentifier NODE_IDENTIFIER =
  49         new NodeIdentifier(QName.create("ns", "2016-02-28", "container"));
  50
  51     private RestconfStrategy mdsalStrategy;
  52     private RestconfStrategy netconfStrategy;
  53     @Mock
  54     private NetconfDataTreeService netconfService;
  55     @Mock
  56     private InstanceIdentifierContext context;
  57     @Mock
  58     private DOMDataTreeReadTransaction read;
  59     @Mock
  60     private EffectiveModelContext schemaContext;
  61     @Mock
  62     private DOMDataBroker mockDataBroker;
  63
  64     @Before
  65     public void setUp() {
  66         // FIXME: these tests need to be parameterized somehow. The trouble is we need mocking before we invoke
  67         //        the strategy. This needs some more thought.
  68         doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
  69         mdsalStrategy = new MdsalRestconfStrategy(mockDataBroker);
  70         netconfStrategy = new NetconfRestconfStrategy(netconfService);
  71     }
  72
  73     @Test
  74     public void readDataConfigTest() {
  75         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
  76                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
  77         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path);
  78         NormalizedNode normalizedNode = readData(ContentParam.CONFIG, DATA.path, mdsalStrategy);
  79         assertEquals(DATA.data3, normalizedNode);
  80
  81         normalizedNode = readData(ContentParam.CONFIG, DATA.path, netconfStrategy);
  82         assertEquals(DATA.data3, normalizedNode);
  83     }
  84
  85     @Test
  86     public void readAllHavingOnlyConfigTest() {
  87         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
  88                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
  89         doReturn(immediateFluentFuture(Optional.empty())).when(read)
  90                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path);
  91         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path);
  92         doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).get(DATA.path);
  93         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.path, mdsalStrategy);
  94         assertEquals(DATA.data3, normalizedNode);
  95
  96         normalizedNode = readData(ContentParam.ALL, DATA.path, netconfStrategy);
  97         assertEquals(DATA.data3, normalizedNode);
  98     }
  99
 100     @Test
 101     public void readAllHavingOnlyNonConfigTest() {
 102         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(read)
 103                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path2);
 104         doReturn(immediateFluentFuture(Optional.empty())).when(read)
 105                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path2);
 106         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(netconfService).get(DATA.path2);
 107         doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(DATA.path2);
 108         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.path2, mdsalStrategy);
 109         assertEquals(DATA.data2, normalizedNode);
 110
 111         normalizedNode = readData(ContentParam.ALL, DATA.path2, netconfStrategy);
 112         assertEquals(DATA.data2, normalizedNode);
 113     }
 114
 115     @Test
 116     public void readDataNonConfigTest() {
 117         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(read)
 118                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path2);
 119         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(netconfService).get(DATA.path2);
 120         NormalizedNode normalizedNode = readData(ContentParam.NONCONFIG, DATA.path2, mdsalStrategy);
 121         assertEquals(DATA.data2, normalizedNode);
 122
 123         normalizedNode = readData(ContentParam.NONCONFIG, DATA.path2, netconfStrategy);
 124         assertEquals(DATA.data2, normalizedNode);
 125     }
 126
 127     @Test
 128     public void readContainerDataAllTest() {
 129         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
 130                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
 131         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read)
 132                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path);
 133         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path);
 134         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(netconfService).get(DATA.path);
 135         final ContainerNode checkingData = Builders
 136                 .containerBuilder()
 137                 .withNodeIdentifier(NODE_IDENTIFIER)
 138                 .withChild(DATA.contentLeaf)
 139                 .withChild(DATA.contentLeaf2)
 140                 .build();
 141         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.path, mdsalStrategy);
 142         assertEquals(checkingData, normalizedNode);
 143
 144         normalizedNode = readData(ContentParam.ALL, DATA.path, netconfStrategy);
 145         assertEquals(checkingData, normalizedNode);
 146     }
 147
 148     @Test
 149     public void readContainerDataConfigNoValueOfContentTest() {
 150         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
 151                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
 152         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read)
 153                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path);
 154         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path);
 155         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(netconfService).get(DATA.path);
 156         final ContainerNode checkingData = Builders
 157                 .containerBuilder()
 158                 .withNodeIdentifier(NODE_IDENTIFIER)
 159                 .withChild(DATA.contentLeaf)
 160                 .withChild(DATA.contentLeaf2)
 161                 .build();
 162         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.path, mdsalStrategy);
 163         assertEquals(checkingData, normalizedNode);
 164
 165         normalizedNode = readData(ContentParam.ALL, DATA.path, netconfStrategy);
 166         assertEquals(checkingData, normalizedNode);
 167     }
 168
 169     @Test
 170     public void readListDataAllTest() {
 171         doReturn(immediateFluentFuture(Optional.of(DATA.listData))).when(read)
 172                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
 173         doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(read)
 174                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
 175         doReturn(immediateFluentFuture(Optional.of(DATA.listData))).when(netconfService).get(DATA.path3);
 176         doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(netconfService).getConfig(DATA.path3);
 177         final MapNode checkingData = Builders
 178                 .mapBuilder()
 179                 .withNodeIdentifier(new NodeIdentifier(QName.create("ns", "2016-02-28", "list")))
 180                 .withChild(DATA.checkData)
 181                 .build();
 182         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.path3, mdsalStrategy);
 183         assertEquals(checkingData, normalizedNode);
 184
 185         normalizedNode = readData(ContentParam.ALL, DATA.path3, netconfStrategy);
 186         assertEquals(checkingData, normalizedNode);
 187     }
 188
 189     @Test
 190     public void readOrderedListDataAllTest() {
 191         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode1))).when(read)
 192                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
 193         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(read)
 194                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
 195         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode1))).when(netconfService).get(DATA.path3);
 196         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(netconfService)
 197                 .getConfig(DATA.path3);
 198         final MapNode expectedData = Builders.orderedMapBuilder()
 199                 .withNodeIdentifier(new NodeIdentifier(DATA.listQname))
 200                 .withChild(DATA.checkData)
 201                 .build();
 202         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.path3,
 203                 mdsalStrategy);
 204         assertEquals(expectedData, normalizedNode);
 205
 206         normalizedNode = readData(ContentParam.ALL, DATA.path3, netconfStrategy);
 207         assertEquals(expectedData, normalizedNode);
 208     }
 209
 210     @Test
 211     public void readUnkeyedListDataAllTest() {
 212         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode1))).when(read)
 213                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
 214         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(read)
 215                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
 216         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode1))).when(netconfService).get(DATA.path3);
 217         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(netconfService)
 218                 .getConfig(DATA.path3);
 219         final UnkeyedListNode expectedData = Builders.unkeyedListBuilder()
 220                 .withNodeIdentifier(new NodeIdentifier(DATA.listQname))
 221                 .withChild(Builders.unkeyedListEntryBuilder()
 222                         .withNodeIdentifier(new NodeIdentifier(DATA.listQname))
 223                         .withChild(DATA.unkeyedListEntryNode1.body().iterator().next())
 224                         .withChild(DATA.unkeyedListEntryNode2.body().iterator().next()).build()).build();
 225         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.path3, mdsalStrategy);
 226         assertEquals(expectedData, normalizedNode);
 227
 228         normalizedNode = readData(ContentParam.ALL, DATA.path3, netconfStrategy);
 229         assertEquals(expectedData, normalizedNode);
 230     }
 231
 232     @Test
 233     public void readLeafListDataAllTest() {
 234         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode1))).when(read)
 235                 .read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath);
 236         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(read)
 237                 .read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath);
 238         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode1))).when(netconfService)
 239                 .get(DATA.leafSetNodePath);
 240         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(netconfService)
 241                 .getConfig(DATA.leafSetNodePath);
 242         final LeafSetNode<String> expectedData = Builders.<String>leafSetBuilder()
 243                 .withNodeIdentifier(new NodeIdentifier(DATA.leafListQname))
 244                 .withValue(ImmutableList.<LeafSetEntryNode<String>>builder()
 245                         .addAll(DATA.leafSetNode1.body())
 246                         .addAll(DATA.leafSetNode2.body())
 247                         .build())
 248                 .build();
 249         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.leafSetNodePath,
 250                 mdsalStrategy);
 251         assertEquals(expectedData, normalizedNode);
 252
 253         normalizedNode = readData(ContentParam.ALL, DATA.leafSetNodePath, netconfStrategy);
 254         assertEquals(expectedData, normalizedNode);
 255     }
 256
 257     @Test
 258     public void readOrderedLeafListDataAllTest() {
 259         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode1))).when(read)
 260                 .read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath);
 261         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(read)
 262                 .read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath);
 263         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode1))).when(netconfService)
 264                 .get(DATA.leafSetNodePath);
 265         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(netconfService)
 266                 .getConfig(DATA.leafSetNodePath);
 267         final LeafSetNode<String> expectedData = Builders.<String>orderedLeafSetBuilder()
 268                 .withNodeIdentifier(new NodeIdentifier(DATA.leafListQname))
 269                 .withValue(ImmutableList.<LeafSetEntryNode<String>>builder()
 270                         .addAll(DATA.orderedLeafSetNode1.body())
 271                         .addAll(DATA.orderedLeafSetNode2.body())
 272                         .build())
 273                 .build();
 274         NormalizedNode normalizedNode = readData(ContentParam.ALL, DATA.leafSetNodePath,
 275                 mdsalStrategy);
 276         assertEquals(expectedData, normalizedNode);
 277
 278         normalizedNode = readData(ContentParam.ALL, DATA.leafSetNodePath, netconfStrategy);
 279         assertEquals(expectedData, normalizedNode);
 280     }
 281
 282     @Test
 283     public void readDataWrongPathOrNoContentTest() {
 284         doReturn(immediateFluentFuture(Optional.empty())).when(read)
 285                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path2);
 286         doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(DATA.path2);
 287         NormalizedNode normalizedNode = readData(ContentParam.CONFIG, DATA.path2, mdsalStrategy);
 288         assertNull(normalizedNode);
 289
 290         normalizedNode = readData(ContentParam.CONFIG, DATA.path2, netconfStrategy);
 291         assertNull(normalizedNode);
 292     }
 293
 294     /**
 295      * Read specific type of data from data store via transaction.
 296      *
 297      * @param content        type of data to read (config, state, all)
 298      * @param strategy       {@link RestconfStrategy} - wrapper for variables
 299      * @return {@link NormalizedNode}
 300      */
 301     private @Nullable NormalizedNode readData(final @NonNull ContentParam content,
 302             final YangInstanceIdentifier path, final @NonNull RestconfStrategy strategy) {
 303         return ReadDataTransactionUtil.readData(content, path, strategy, null, schemaContext);
 304     }
 305 }