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.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertSame;
  15 import static org.junit.Assert.assertThrows;
  16 import static org.junit.Assert.assertTrue;
  17 import static org.junit.Assert.fail;
  18 import static org.mockito.Mockito.doReturn;
  19 import static org.mockito.Mockito.mock;
  20 import static org.mockito.Mockito.when;
  21 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
  22
  23 import com.google.common.collect.ImmutableList;
  24 import java.util.List;
  25 import java.util.Optional;
  26 import java.util.Set;
  27 import javax.ws.rs.core.MultivaluedHashMap;
  28 import javax.ws.rs.core.UriInfo;
  29 import org.eclipse.jdt.annotation.NonNull;
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.junit.runner.RunWith;
  34 import org.mockito.Mock;
  35 import org.mockito.junit.MockitoJUnitRunner;
  36 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  37 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  38 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  39 import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
  40 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
  41 import org.opendaylight.restconf.common.context.WriterParameters;
  42 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
  43 import org.opendaylight.restconf.common.errors.RestconfError;
  44 import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
  45 import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
  46 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
  47 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
  48 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
  49 import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfDataServiceConstant.ReadData;
  50 import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfDataServiceConstant.ReadData.WithDefaults;
  51 import org.opendaylight.yangtools.yang.common.QName;
  52 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  53 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  54 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  55 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  56 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  57 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  58 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
  59 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  60 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  61 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  62 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  63
  64 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  65 public class ReadDataTransactionUtilTest {
  66
  67     private static final TestData DATA = new TestData();
  68     private static final YangInstanceIdentifier.NodeIdentifier NODE_IDENTIFIER = new YangInstanceIdentifier
  69             .NodeIdentifier(QName.create("ns", "2016-02-28", "container"));
  70
  71     private RestconfStrategy mdsalStrategy;
  72     private RestconfStrategy netconfStrategy;
  73     @Mock
  74     private NetconfDataTreeService netconfService;
  75     @Mock
  76     private InstanceIdentifierContext<ContainerSchemaNode> context;
  77     @Mock
  78     private DOMDataTreeReadTransaction read;
  79     @Mock
  80     private EffectiveModelContext schemaContext;
  81     @Mock
  82     private ContainerSchemaNode containerSchemaNode;
  83     @Mock
  84     private LeafSchemaNode containerChildNode;
  85     private QName containerChildQName;
  86
  87     @Before
  88     public void setUp() {
  89         containerChildQName = QName.create("ns", "2016-02-28", "container-child");
  90
  91         when(context.getSchemaContext()).thenReturn(schemaContext);
  92         when(context.getSchemaNode()).thenReturn(containerSchemaNode);
  93         when(containerSchemaNode.getQName()).thenReturn(NODE_IDENTIFIER.getNodeType());
  94         when(containerChildNode.getQName()).thenReturn(containerChildQName);
  95         when(containerSchemaNode.dataChildByName(containerChildQName)).thenReturn(containerChildNode);
  96
  97         DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
  98         doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
  99         mdsalStrategy = new MdsalRestconfStrategy(mockDataBroker);
 100         netconfStrategy = new NetconfRestconfStrategy(this.netconfService);
 101     }
 102
 103     @Test
 104     public void readDataConfigTest() {
 105         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
 106                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
 107         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path);
 108         final String valueOfContent = RestconfDataServiceConstant.ReadData.CONFIG;
 109         NormalizedNode normalizedNode = readData(valueOfContent, DATA.path, mdsalStrategy);
 110         assertEquals(DATA.data3, normalizedNode);
 111
 112         normalizedNode = readData(valueOfContent, DATA.path, netconfStrategy);
 113         assertEquals(DATA.data3, normalizedNode);
 114     }
 115
 116     @Test
 117     public void readAllHavingOnlyConfigTest() {
 118         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
 119                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
 120         doReturn(immediateFluentFuture(Optional.empty())).when(read)
 121                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path);
 122         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path);
 123         doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).get(DATA.path);
 124         final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
 125         NormalizedNode normalizedNode = readData(valueOfContent, DATA.path, mdsalStrategy);
 126         assertEquals(DATA.data3, normalizedNode);
 127
 128         normalizedNode = readData(valueOfContent, DATA.path, netconfStrategy);
 129         assertEquals(DATA.data3, normalizedNode);
 130     }
 131
 132     @Test
 133     public void readAllHavingOnlyNonConfigTest() {
 134         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(read)
 135                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path2);
 136         doReturn(immediateFluentFuture(Optional.empty())).when(read)
 137                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path2);
 138         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(this.netconfService).get(DATA.path2);
 139         doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(DATA.path2);
 140         final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
 141         NormalizedNode normalizedNode = readData(valueOfContent, DATA.path2, mdsalStrategy);
 142         assertEquals(DATA.data2, normalizedNode);
 143
 144         normalizedNode = readData(valueOfContent, DATA.path2, netconfStrategy);
 145         assertEquals(DATA.data2, normalizedNode);
 146     }
 147
 148     @Test
 149     public void readDataNonConfigTest() {
 150         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(read)
 151                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path2);
 152         doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(this.netconfService).get(DATA.path2);
 153         final String valueOfContent = RestconfDataServiceConstant.ReadData.NONCONFIG;
 154         NormalizedNode normalizedNode = readData(valueOfContent, DATA.path2, mdsalStrategy);
 155         assertEquals(DATA.data2, normalizedNode);
 156
 157         normalizedNode = readData(valueOfContent, DATA.path2, netconfStrategy);
 158         assertEquals(DATA.data2, normalizedNode);
 159     }
 160
 161     @Test
 162     public void readContainerDataAllTest() {
 163         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
 164                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
 165         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read)
 166                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path);
 167         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path);
 168         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(this.netconfService).get(DATA.path);
 169         final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
 170         final ContainerNode checkingData = Builders
 171                 .containerBuilder()
 172                 .withNodeIdentifier(NODE_IDENTIFIER)
 173                 .withChild(DATA.contentLeaf)
 174                 .withChild(DATA.contentLeaf2)
 175                 .build();
 176         NormalizedNode normalizedNode = readData(valueOfContent, DATA.path, mdsalStrategy);
 177         assertEquals(checkingData, normalizedNode);
 178
 179         normalizedNode = readData(valueOfContent, DATA.path, netconfStrategy);
 180         assertEquals(checkingData, normalizedNode);
 181     }
 182
 183     @Test
 184     public void readContainerDataConfigNoValueOfContentTest() {
 185         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read)
 186                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path);
 187         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read)
 188                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path);
 189         doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path);
 190         doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(this.netconfService).get(DATA.path);
 191         final ContainerNode checkingData = Builders
 192                 .containerBuilder()
 193                 .withNodeIdentifier(NODE_IDENTIFIER)
 194                 .withChild(DATA.contentLeaf)
 195                 .withChild(DATA.contentLeaf2)
 196                 .build();
 197         NormalizedNode normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.path, mdsalStrategy);
 198         assertEquals(checkingData, normalizedNode);
 199
 200         normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.path, netconfStrategy);
 201         assertEquals(checkingData, normalizedNode);
 202     }
 203
 204     @Test
 205     public void readListDataAllTest() {
 206         doReturn(immediateFluentFuture(Optional.of(DATA.listData))).when(read)
 207                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
 208         doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(read)
 209                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
 210         doReturn(immediateFluentFuture(Optional.of(DATA.listData))).when(this.netconfService).get(DATA.path3);
 211         doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(this.netconfService).getConfig(DATA.path3);
 212         final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL;
 213         final MapNode checkingData = Builders
 214                 .mapBuilder()
 215                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create("ns", "2016-02-28", "list")))
 216                 .withChild(DATA.checkData)
 217                 .build();
 218         NormalizedNode normalizedNode = readData(valueOfContent, DATA.path3, mdsalStrategy);
 219         assertEquals(checkingData, normalizedNode);
 220
 221         normalizedNode = readData(valueOfContent, DATA.path3, netconfStrategy);
 222         assertEquals(checkingData, normalizedNode);
 223     }
 224
 225     @Test
 226     public void readOrderedListDataAllTest() {
 227         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode1))).when(read)
 228                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
 229         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(read)
 230                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
 231         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode1))).when(this.netconfService).get(DATA.path3);
 232         doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(this.netconfService)
 233                 .getConfig(DATA.path3);
 234         final MapNode expectedData = Builders.orderedMapBuilder()
 235                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(DATA.listQname)).withChild(DATA.checkData)
 236                 .build();
 237         NormalizedNode normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.path3,
 238                 mdsalStrategy);
 239         assertEquals(expectedData, normalizedNode);
 240
 241         normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.path3, netconfStrategy);
 242         assertEquals(expectedData, normalizedNode);
 243     }
 244
 245     @Test
 246     public void readUnkeyedListDataAllTest() {
 247         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode1))).when(read)
 248                 .read(LogicalDatastoreType.OPERATIONAL, DATA.path3);
 249         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(read)
 250                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path3);
 251         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode1))).when(this.netconfService).get(DATA.path3);
 252         doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(this.netconfService)
 253                 .getConfig(DATA.path3);
 254         final UnkeyedListNode expectedData = Builders.unkeyedListBuilder()
 255                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(DATA.listQname))
 256                 .withChild(Builders.unkeyedListEntryBuilder().withNodeIdentifier(
 257                         new YangInstanceIdentifier.NodeIdentifier(DATA.listQname))
 258                         .withChild(DATA.unkeyedListEntryNode1.body().iterator().next())
 259                         .withChild(DATA.unkeyedListEntryNode2.body().iterator().next()).build()).build();
 260         NormalizedNode normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.path3, mdsalStrategy);
 261         assertEquals(expectedData, normalizedNode);
 262
 263         normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.path3, netconfStrategy);
 264         assertEquals(expectedData, normalizedNode);
 265     }
 266
 267     @Test
 268     public void readLeafListDataAllTest() {
 269         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode1))).when(read)
 270                 .read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath);
 271         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(read)
 272                 .read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath);
 273         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode1))).when(this.netconfService)
 274                 .get(DATA.leafSetNodePath);
 275         doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(this.netconfService)
 276                 .getConfig(DATA.leafSetNodePath);
 277         final LeafSetNode<String> expectedData = Builders.<String>leafSetBuilder().withNodeIdentifier(
 278                 new YangInstanceIdentifier.NodeIdentifier(DATA.leafListQname)).withValue(
 279                         ImmutableList.<LeafSetEntryNode<String>>builder().addAll(DATA.leafSetNode1.body())
 280                         .addAll(DATA.leafSetNode2.body()).build()).build();
 281         NormalizedNode normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.leafSetNodePath,
 282                 mdsalStrategy);
 283         assertEquals(expectedData, normalizedNode);
 284
 285         normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.leafSetNodePath, netconfStrategy);
 286         assertEquals(expectedData, normalizedNode);
 287     }
 288
 289     @Test
 290     public void readOrderedLeafListDataAllTest() {
 291         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode1))).when(read)
 292                 .read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath);
 293         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(read)
 294                 .read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath);
 295         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode1))).when(this.netconfService)
 296                 .get(DATA.leafSetNodePath);
 297         doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(this.netconfService)
 298                 .getConfig(DATA.leafSetNodePath);
 299         final LeafSetNode<String> expectedData = Builders.<String>orderedLeafSetBuilder().withNodeIdentifier(
 300                 new YangInstanceIdentifier.NodeIdentifier(DATA.leafListQname)).withValue(
 301                         ImmutableList.<LeafSetEntryNode<String>>builder().addAll(DATA.orderedLeafSetNode1.body())
 302                         .addAll(DATA.orderedLeafSetNode2.body()).build()).build();
 303         NormalizedNode normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.leafSetNodePath,
 304                 mdsalStrategy);
 305         assertEquals(expectedData, normalizedNode);
 306
 307         normalizedNode = readData(RestconfDataServiceConstant.ReadData.ALL, DATA.leafSetNodePath, netconfStrategy);
 308         assertEquals(expectedData, normalizedNode);
 309     }
 310
 311     @Test
 312     public void readDataWrongPathOrNoContentTest() {
 313         doReturn(immediateFluentFuture(Optional.empty())).when(read)
 314                 .read(LogicalDatastoreType.CONFIGURATION, DATA.path2);
 315         doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(DATA.path2);
 316         final String valueOfContent = RestconfDataServiceConstant.ReadData.CONFIG;
 317         NormalizedNode normalizedNode = readData(valueOfContent, DATA.path2, mdsalStrategy);
 318         assertNull(normalizedNode);
 319
 320         normalizedNode = readData(valueOfContent, DATA.path2, netconfStrategy);
 321         assertNull(normalizedNode);
 322     }
 323
 324     @Test(expected = RestconfDocumentedException.class)
 325     public void readDataFailTest() {
 326         final String valueOfContent = "nonsense";
 327         NormalizedNode normalizedNode = readData(valueOfContent, null, mdsalStrategy);
 328         assertNull(normalizedNode);
 329
 330         normalizedNode = readData(valueOfContent, null, netconfStrategy);
 331         assertNull(normalizedNode);
 332     }
 333
 334     /**
 335      * Test of parsing default parameters from URI request.
 336      */
 337     @Test
 338     public void parseUriParametersDefaultTest() {
 339         final UriInfo uriInfo = mock(UriInfo.class);
 340         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 341
 342         // no parameters, default values should be used
 343         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 344
 345         final WriterParameters parsedParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 346
 347         assertEquals("Not correctly parsed URI parameter",
 348                 RestconfDataServiceConstant.ReadData.ALL, parsedParameters.getContent());
 349         assertNull("Not correctly parsed URI parameter",
 350                 parsedParameters.getDepth());
 351         assertNull("Not correctly parsed URI parameter",
 352                 parsedParameters.getFields());
 353     }
 354
 355     /**
 356      * Test of parsing user defined parameters from URI request.
 357      */
 358     @Test
 359     public void parseUriParametersUserDefinedTest() {
 360         final UriInfo uriInfo = mock(UriInfo.class);
 361         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 362
 363         final String content = "config";
 364         final String depth = "10";
 365         final String fields = containerChildQName.getLocalName();
 366
 367         parameters.put("content", List.of(content));
 368         parameters.put("depth", List.of(depth));
 369         parameters.put("fields", List.of(fields));
 370
 371         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 372
 373         final WriterParameters parsedParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 374
 375         // content
 376         assertEquals("Not correctly parsed URI parameter",
 377                 content, parsedParameters.getContent());
 378
 379         // depth
 380         assertNotNull("Not correctly parsed URI parameter",
 381                 parsedParameters.getDepth());
 382         assertEquals("Not correctly parsed URI parameter",
 383                 depth, parsedParameters.getDepth().toString());
 384
 385         // fields
 386         assertNotNull("Not correctly parsed URI parameter",
 387                 parsedParameters.getFields());
 388         assertEquals("Not correctly parsed URI parameter",
 389                 1, parsedParameters.getFields().size());
 390         assertEquals("Not correctly parsed URI parameter",
 391                 1, parsedParameters.getFields().get(0).size());
 392         assertEquals("Not correctly parsed URI parameter",
 393                 containerChildQName, parsedParameters.getFields().get(0).iterator().next());
 394     }
 395
 396     /**
 397      * Negative test of parsing request URI parameters when content parameter has not allowed value.
 398      */
 399     @Test
 400     public void parseUriParametersContentParameterNegativeTest() {
 401         final UriInfo uriInfo = mock(UriInfo.class);
 402         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 403
 404         parameters.put("content", List.of("not-allowed-parameter-value"));
 405         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 406
 407         try {
 408             ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 409             fail("Test expected to fail due to not allowed parameter value");
 410         } catch (final RestconfDocumentedException e) {
 411             // Bad request
 412             assertEquals("Error type is not correct", ErrorType.PROTOCOL, e.getErrors().get(0).getErrorType());
 413             assertEquals("Error tag is not correct", ErrorTag.INVALID_VALUE, e.getErrors().get(0).getErrorTag());
 414             assertEquals("Error status code is not correct", 400, e.getErrors().get(0).getErrorTag().getStatusCode());
 415         }
 416     }
 417
 418     /**
 419      * Negative test of parsing request URI parameters when depth parameter has not allowed value.
 420      */
 421     @Test
 422     public void parseUriParametersDepthParameterNegativeTest() {
 423         final UriInfo uriInfo = mock(UriInfo.class);
 424         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 425
 426         // inserted value is not allowed
 427         parameters.put("depth", List.of("bounded"));
 428         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 429
 430         try {
 431             ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 432             fail("Test expected to fail due to not allowed parameter value");
 433         } catch (final RestconfDocumentedException e) {
 434             // Bad request
 435             assertEquals("Error type is not correct", ErrorType.PROTOCOL, e.getErrors().get(0).getErrorType());
 436             assertEquals("Error tag is not correct", ErrorTag.INVALID_VALUE, e.getErrors().get(0).getErrorTag());
 437             assertEquals("Error status code is not correct", 400, e.getErrors().get(0).getErrorTag().getStatusCode());
 438         }
 439     }
 440
 441     /**
 442      * Negative test of parsing request URI parameters when depth parameter has not allowed value (less than minimum).
 443      */
 444     @Test
 445     public void parseUriParametersDepthMinimalParameterNegativeTest() {
 446         final UriInfo uriInfo = mock(UriInfo.class);
 447         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 448
 449         // inserted value is too low
 450         parameters.put(
 451                 "depth", List.of(String.valueOf(RestconfDataServiceConstant.ReadData.MIN_DEPTH - 1)));
 452         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 453
 454         try {
 455             ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 456             fail("Test expected to fail due to not allowed parameter value");
 457         } catch (final RestconfDocumentedException e) {
 458             // Bad request
 459             assertEquals("Error type is not correct", ErrorType.PROTOCOL, e.getErrors().get(0).getErrorType());
 460             assertEquals("Error tag is not correct", ErrorTag.INVALID_VALUE, e.getErrors().get(0).getErrorTag());
 461             assertEquals("Error status code is not correct", 400, e.getErrors().get(0).getErrorTag().getStatusCode());
 462         }
 463     }
 464
 465     /**
 466      * Negative test of parsing request URI parameters when depth parameter has not allowed value (more than maximum).
 467      */
 468     @Test
 469     public void parseUriParametersDepthMaximalParameterNegativeTest() {
 470         final UriInfo uriInfo = mock(UriInfo.class);
 471         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 472
 473         // inserted value is too high
 474         parameters.put(
 475                 "depth", List.of(String.valueOf(RestconfDataServiceConstant.ReadData.MAX_DEPTH + 1)));
 476         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 477
 478         try {
 479             ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 480             fail("Test expected to fail due to not allowed parameter value");
 481         } catch (final RestconfDocumentedException e) {
 482             // Bad request
 483             assertEquals("Error type is not correct", ErrorType.PROTOCOL, e.getErrors().get(0).getErrorType());
 484             assertEquals("Error tag is not correct", ErrorTag.INVALID_VALUE, e.getErrors().get(0).getErrorTag());
 485             assertEquals("Error status code is not correct", 400, e.getErrors().get(0).getErrorTag().getStatusCode());
 486         }
 487     }
 488
 489     /**
 490      * Testing parsing of with-defaults parameter which value doesn't match report-all or report-all-tagged patterns
 491      * - non-reporting setting.
 492      */
 493     @Test
 494     public void parseUriParametersWithDefaultAndNonTaggedTest() {
 495         // preparation of input data
 496         final UriInfo uriInfo = mock(UriInfo.class);
 497         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 498         parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS, List.of("explicit"));
 499         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 500
 501         final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 502         assertSame(WithDefaults.EXPLICIT.value(), writerParameters.getWithDefault());
 503         assertFalse(writerParameters.isTagged());
 504     }
 505
 506     /**
 507      * Testing parsing of with-defaults parameter which value which is not supported.
 508      */
 509     @Test
 510     public void parseUriParametersWithDefaultInvalidTest() {
 511         // preparation of input data
 512         final UriInfo uriInfo = mock(UriInfo.class);
 513         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 514         parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS, List.of("invalid"));
 515         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 516
 517         final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
 518             () -> ReadDataTransactionUtil.parseUriParameters(context, uriInfo));
 519         final List<RestconfError> errors = ex.getErrors();
 520         assertEquals(1, errors.size());
 521         assertEquals(ErrorTag.INVALID_VALUE, errors.get(0).getErrorTag());
 522     }
 523
 524     /**
 525      * Testing parsing of with-defaults parameter which value matches 'report-all-tagged' setting - default value should
 526      * be set to {@code null} and tagged flag should be set to {@code true}.
 527      */
 528     @Test
 529     public void parseUriParametersWithDefaultAndTaggedTest() {
 530         // preparation of input data
 531         final UriInfo uriInfo = mock(UriInfo.class);
 532         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 533         parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS,
 534                 List.of(ReadData.WithDefaults.REPORT_ALL_TAGGED.value()));
 535         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 536
 537         final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 538         assertNull(writerParameters.getWithDefault());
 539         assertTrue(writerParameters.isTagged());
 540     }
 541
 542     /**
 543      * Testing parsing of with-defaults parameter which value matches 'report-all' setting - default value should
 544      * be set to {@code null} and tagged flag should be set to {@code false}.
 545      */
 546     @Test
 547     public void parseUriParametersWithDefaultAndReportAllTest() {
 548         // preparation of input data
 549         final UriInfo uriInfo = mock(UriInfo.class);
 550         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 551         parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS,
 552                 List.of(ReadData.WithDefaults.REPORT_ALL.value()));
 553         when(uriInfo.getQueryParameters()).thenReturn(parameters);
 554
 555         final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
 556         assertNull(writerParameters.getWithDefault());
 557         assertFalse(writerParameters.isTagged());
 558     }
 559
 560     /**
 561      * Test when parameter is present at most once.
 562      */
 563     @Test
 564     public void checkParameterCountTest() {
 565         ReadDataTransactionUtil.checkParameterCount(List.of("all"), RestconfDataServiceConstant.ReadData.CONTENT);
 566     }
 567
 568     /**
 569      * Test when parameter is present more than once.
 570      */
 571     @Test
 572     public void checkParameterCountNegativeTest() {
 573         final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
 574             () -> ReadDataTransactionUtil.checkParameterCount(List.of("config", "nonconfig", "all"),
 575                     RestconfDataServiceConstant.ReadData.CONTENT));
 576         assertEquals("Error type is not correct", ErrorType.PROTOCOL, ex.getErrors().get(0).getErrorType());
 577         assertEquals("Error tag is not correct", ErrorTag.INVALID_VALUE, ex.getErrors().get(0).getErrorTag());
 578         assertEquals("Error status code is not correct", 400, ex.getErrors().get(0).getErrorTag().getStatusCode());
 579     }
 580
 581
 582     /**
 583      * Test when all parameters are allowed.
 584      */
 585     @Test
 586     public void checkParametersTypesTest() {
 587         ReadDataTransactionUtil.checkParametersTypes(Set.of("content"),
 588                 RestconfDataServiceConstant.ReadData.CONTENT, RestconfDataServiceConstant.ReadData.DEPTH);
 589     }
 590
 591     /**
 592      * Test when not allowed parameter type is used.
 593      */
 594     @Test
 595     public void checkParametersTypesNegativeTest() {
 596         final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
 597             () -> ReadDataTransactionUtil.checkParametersTypes(Set.of("not-allowed-parameter"),
 598                     RestconfDataServiceConstant.ReadData.CONTENT, RestconfDataServiceConstant.ReadData.DEPTH));
 599         assertEquals("Error type is not correct", ErrorType.PROTOCOL, ex.getErrors().get(0).getErrorType());
 600         assertEquals("Error tag is not correct", ErrorTag.INVALID_VALUE, ex.getErrors().get(0).getErrorTag());
 601         assertEquals("Error status code is not correct", 400, ex.getErrors().get(0).getErrorTag().getStatusCode());
 602     }
 603
 604     /**
 605      * Read specific type of data from data store via transaction.
 606      *
 607      * @param valueOfContent type of data to read (config, state, all)
 608      * @param strategy       {@link RestconfStrategy} - wrapper for variables
 609      * @return {@link NormalizedNode}
 610      */
 611     private @Nullable NormalizedNode readData(final @NonNull String valueOfContent,
 612             final YangInstanceIdentifier path, final @NonNull RestconfStrategy strategy) {
 613         return ReadDataTransactionUtil.readData(valueOfContent, path, strategy, null, schemaContext);
 614     }
 615 }