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